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

StreamingCommunity/Api/Site/streamingcommunity/series.py

@@ -1,206 +0,0 @@
-# 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 SITE_NAME, SERIES_FOLDER
-
-
-
-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(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 = TVShowManager()
-    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" or last_command == "quit":
-        console.print("\n[red]Quit [white]...")
-        sys.exit(0)
-
-    return last_command

StreamingCommunity/Api/Site/streamingcommunity/site.py

@@ -1,142 +0,0 @@
-# 10.12.23
-
-import json
-import logging
-import secrets
-
-
-# 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
-
-
-# Config
-from .costant import SITE_NAME, DOMAIN_NOW
-
-
-# Variable
-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 get_version(domain: str):
-    """
-    Extracts the version from the HTML text of a webpage.
-
-    Parameters:
-        - domain (str): The domain of the site.
-
-    Returns:
-        str: The version extracted from the webpage.
-    """
-    try:
-        response = httpx.get(
-            url=f"https://{SITE_NAME}.{domain}/", 
-            headers={'User-Agent': get_headers()}, 
-            timeout=max_timeout
-        )
-        response.raise_for_status()
-
-        # Parse request to site
-        soup = BeautifulSoup(response.text, "html.parser")
-
-        # Extract version
-        version = json.loads(soup.find("div", {"id": "app"}).get("data-page"))['version']
-        console.print(f"[cyan]Get version [white]=> [red]{version} \n")
-
-        return version
-    
-    except Exception as e:
-        logging.error(f"Error extracting version: {e}")
-        raise
-
-
-def get_version_and_domain():
-    """
-    Retrieve the current version and domain of the site.
-
-    This function performs the following steps:
-        - Determines the correct domain to use for the site by searching for a specific meta tag.
-        - Fetches the content of the site to extract the version information.
-    """
-
-    # 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}")
-
-    try:
-        version = get_version(domain_to_use)
-    except:
-        console.print("[green]Auto generate version ...")
-        version = secrets.token_hex(32 // 2)
-            
-    return version, domain_to_use
-
-
-def title_search(title_search: str, domain: str) -> int:
-    """
-    Search for titles based on a search query.
-
-    Parameters:
-        - title_search (str): The title to search for.
-        - domain (str): The domain to search on.
-
-    Returns:
-        int: The number of titles found.
-    """
-    media_search_manager.clear()
-    table_show_manager.clear()
-    
-    try:
-        response = httpx.get(
-            url=f"https://{SITE_NAME}.{domain}/api/search?q={title_search.replace(' ', '+')}", 
-            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}")
-
-    for dict_title in response.json()['data']:
-        try:
-
-            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'),
-                'date': dict_title.get('last_air_date'),
-                'score': dict_title.get('score')
-            })
-
-        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/streamingcommunity/util/ScrapeSerie.py

@@ -1,123 +0,0 @@
-# 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"))
-                  
-            """
-            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

@@ -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