StreamingCommunity 1.9.1__py3-none-any.whl → 1.9.2__py3-none-any.whl

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

@@ -1,113 +0,0 @@
-# 01.03.24
-
-import logging
-
-
-# External libraries
-import httpx
-
-
-# Internal utilities
-from StreamingCommunity.Util.headers import get_headers
-from StreamingCommunity.Util._jsonConfig import config_manager
-from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager, 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.obj_season_manager: SeasonManager = SeasonManager()
-            self.obj_episode_manager: EpisodeManager = EpisodeManager()
-
-    def collect_info_seasons(self) -> None:
-        """
-        Retrieve season information for a TV series from the streaming site.
-        
-        Raises:
-            Exception: If there's an error fetching season information
-        """
-        self.headers = {
-            'user-agent': get_headers(),
-            'x-inertia': 'true', 
-            'x-inertia-version': self.version,
-        }
-
-        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
-            json_response = response.json().get('props', {}).get('title', {}).get('seasons', [])
-                
-            # Add each season to the season manager
-            for dict_season in json_response:
-                self.obj_season_manager.add_season(dict_season)
-
-        except Exception as e:
-            logging.error(f"Error collecting season info: {e}")
-            raise
-
-    def collect_title_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=self.headers, 
-                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.obj_episode_manager.add_episode(dict_episode)
-
-        except Exception as e:
-            logging.error(f"Error collecting title season info: {e}")
-            raise

StreamingCommunity/Api/Template/Class/SearchType.py

@@ -1,101 +0,0 @@
-# 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

@@ -1,5 +0,0 @@
-# 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

StreamingCommunity/Api/Template/Util/get_domain.py

@@ -1,137 +0,0 @@
-# 18.06.24
-
-import sys
-from urllib.parse import urlparse
-
-
-# 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
-
-
-def google_search(query):
-    """
-    Perform a Google search and return the first result.
-
-    Args:
-        query (str): The search query to execute on Google.
-
-    Returns:
-        str: The first URL result from the search, or None if no result is found.
-    """
-    # Perform the search on Google and limit to 1 result
-    search_results = search(query, num_results=1)
-    
-    # Extract the first result
-    first_result = next(search_results, None)
-    
-    if not first_result:
-        console.print("[red]No results found.[/red]")
-    
-    return first_result
-
-def get_final_redirect_url(initial_url, max_timeout):
-    """
-    Follow redirects from the initial URL and return the final URL after all redirects.
-
-    Args:
-        initial_url (str): The URL to start with and follow redirects.
-
-    Returns:
-        str: The final URL after all redirects are followed.
-    """
-
-    # Create a client with redirects enabled
-    try:
-        with httpx.Client(follow_redirects=True, timeout=max_timeout, headers={'user-agent': get_headers()}) as client:
-            response = client.get(initial_url)
-            response.raise_for_status()
-            
-            # Capture the final URL after all redirects
-            final_url = response.url
-        
-        return final_url
-    
-    except Exception as e:
-        console.print(f"[cyan]Test url[white]: [red]{initial_url}, [cyan]error[white]: [red]{e}")
-        return None
-
-def search_domain(site_name: str, base_url: str):
-    """
-    Search for a valid domain for the given site name and base URL.
-
-    Parameters:
-        - site_name (str): The name of the site to search the domain for.
-        - base_url (str): The base URL to construct complete URLs.
-        - follow_redirects (bool): To follow redirect url or not.
-
-    Returns:
-        tuple: The found domain and the complete URL.
-    """
-
-    # Extract config domain
-    max_timeout = config_manager.get_int("REQUESTS", "timeout")
-    domain = str(config_manager.get_dict("SITE", site_name)['domain'])
-
-    try:
-
-        # Test the current domain
-        response_follow = httpx.get(f"{base_url}.{domain}", headers={'user-agent': get_headers()}, timeout=max_timeout, follow_redirects=True)
-        response_follow.raise_for_status()
-
-    except Exception as e:
-
-        query = base_url.split("/")[-1]
-        first_url = google_search(query)
-        console.print(f"[green]First url from google seach[white]: [red]{first_url}")
-
-        if first_url:
-            final_url = get_final_redirect_url(first_url, max_timeout)
-
-            if final_url != None:
-                console.print(f"\n[bold yellow]Suggestion:[/bold yellow] [white](Experimental)\n"
-                            f"[cyan]New final URL[white]: [green]{final_url}")
-                
-                def extract_domain(url):
-                    parsed_url = urlparse(url)
-                    domain = parsed_url.netloc
-                    return domain.split(".")[-1]
-
-                new_domain_extract = extract_domain(str(final_url))
-
-                if msg.ask(f"[red]Do you want to auto update config.json - '[green]{site_name}[red]' with domain: [green]{new_domain_extract}", choices=["y", "n"], default="y").lower() == "y":
-                    
-                    # Update domain in config.json
-                    config_manager.config['SITE'][site_name]['domain'] = new_domain_extract
-                    config_manager.write_config()
-
-                    # Return config domain
-                    #console.print(f"[cyan]Return domain: [red]{new_domain_extract} \n")
-                    return new_domain_extract, f"{base_url}.{new_domain_extract}"
-            
-            else:
-                console.print("[bold red]\nManually change the domain in the JSON file.[/bold red]")
-                raise
-
-        else:
-            console.print("[bold red]No valid URL to follow redirects.[/bold red]")
-
-    # Ensure the URL is in string format before parsing
-    parsed_url = urlparse(str(response_follow.url))
-    parse_domain = parsed_url.netloc
-    tld = parse_domain.split('.')[-1]
-
-    if tld is not None:
-        
-        # Update domain in config.json
-        config_manager.config['SITE'][site_name]['domain'] = tld
-        config_manager.write_config()
-
-    # Return config domain
-    return tld, f"{base_url}.{tld}"

StreamingCommunity/Api/Template/Util/manage_ep.py

@@ -1,153 +0,0 @@
-# 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)", dynamic_format_number(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.
-    """
-
-    # 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:
-        print()
-        raise ValueError(f"Invalid selection: The selected seasons are outside the available range (1-{seasons_count}).")
-
-    return valid_seasons
-
-
-# --> 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.
-    """
-
-    # 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:
-        print()
-        raise ValueError(f"Invalid selection: The selected episodes are outside the available range (1-{episodes_count}).")
-
-    return valid_episodes

StreamingCommunity/Api/Template/Util/recall_search.py

@@ -1,37 +0,0 @@
-# 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

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

StreamingCommunity/Api/Template/site.py

@@ -1,87 +0,0 @@
-# 19.06.24
-
-import sys
-
-
-# Internal utilities
-from StreamingCommunity.Util.console import console
-
-
-# Variable
-available_colors = ['red', 'magenta', 'yellow', 'cyan', 'green', 'blue', 'white']
-column_to_hide = ['Slug', 'Sub_ita', 'Last_air_date', 'Seasons_count', 'Url']
-
-
-def get_select_title(table_show_manager, media_search_manager):
-    """
-    Display a selection of titles and prompt the user to choose one.
-
-    Returns:
-        MediaItem: The selected media item.
-    """
-
-    # Set up table for displaying titles
-    table_show_manager.set_slice_end(10)
-
-    # Determine column_info dynamically for (search site)
-    if not media_search_manager.media_list:
-        console.print("\n[red]No media items available.")
-        return None
-    
-    # Example of available colors for columns
-    available_colors = ['red', 'magenta', 'yellow', 'cyan', 'green', 'blue', 'white']
-    
-    # Retrieve the keys of the first media item as column headers
-    first_media_item = media_search_manager.media_list[0]
-    column_info = {"Index": {'color': available_colors[0]}}  # Always include Index with a fixed color
-
-    # Assign colors to the remaining keys dynamically
-    color_index = 1
-    for key in first_media_item.__dict__.keys():
-
-        if key.capitalize() in column_to_hide:
-            continue
-
-        if key in ('id', 'type', 'name', 'score'):  # Custom prioritization of colors
-            if key == 'type':
-                column_info["Type"] = {'color': 'yellow'}
-            elif key == 'name':
-                column_info["Name"] = {'color': 'magenta'}
-            elif key == 'score':
-                column_info["Score"] = {'color': 'cyan'}
-
-        else:
-            column_info[key.capitalize()] = {'color': available_colors[color_index % len(available_colors)]}
-            color_index += 1
-
-    table_show_manager.add_column(column_info)
-
-    # Populate the table with title information
-    for i, media in enumerate(media_search_manager.media_list):
-        media_dict = {'Index': str(i)}
-
-        for key in first_media_item.__dict__.keys():
-            if key.capitalize() in column_to_hide:
-                continue
-
-            # Ensure all values are strings for rich add table
-            media_dict[key.capitalize()] = str(getattr(media, key))
-
-        table_show_manager.add_tv_show(media_dict)
-
-    # Run the table and handle user input
-    last_command = table_show_manager.run(force_int_input=True, max_int_input=len(media_search_manager.media_list))
-    table_show_manager.clear()
-
-    # Handle user's quit command
-    if last_command == "q":
-        console.print("\n[red]Quit [white]...")
-        sys.exit(0)
-
-    # Check if the selected index is within range
-    if 0 <= int(last_command) < len(media_search_manager.media_list):
-        return media_search_manager.get(int(last_command))
-    
-    else:
-        console.print("\n[red]Wrong index")
-        sys.exit(0)