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

StreamingCommunity/Api/Site/streamingcommunity/site.py

@@ -0,0 +1,137 @@
+# 10.12.23
+
+import sys
+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
+
+
+# Variable
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+def get_version(text: str):
+    """
+    Extracts the version from the HTML text of a webpage.
+
+    Parameters:
+        - text (str): The HTML text of the webpage.
+
+    Returns:
+        str: The version extracted from the webpage.
+        list: Top 10 titles headlines for today.
+    """
+    try:
+
+        # Parse request to site
+        soup = BeautifulSoup(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, base_url = search_domain(SITE_NAME, f"https://{SITE_NAME}")
+
+    # Extract version from the response
+    try:
+        version = get_version(httpx.get(
+            url=base_url, 
+            headers={
+                'user-agent': get_headers()
+            }, 
+            timeout=max_timeout
+        ).text)
+    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}")
+
+    # Add found titles to media search manager
+    for dict_title in response.json()['data']:
+        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')
+        })
+
+    # 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

@@ -0,0 +1,123 @@
+# 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 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
+        """
+        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')
+
+            # Collect info about season
+            self.season_manager = Season(json_response.get('title'))
+            self.season_manager.collect_images(self.base_name, self.domain)
+
+            # Collect first episode info
+            for i, ep in enumerate(json_response.get('loadedSeason').get('episodes')):
+                self.season_manager.episodes.add(ep)
+                self.season_manager.episodes.get(i).collect_image(self.base_name, self.domain)
+            
+        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
+        """
+        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}/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.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

StreamingCommunity/Api/Template/Util/get_domain.py

@@ -0,0 +1,173 @@
+# 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(
+            headers={
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
+                'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+                'User-Agent': get_headers()
+            },
+            follow_redirects=True,
+            timeout=max_timeout
+
+        ) as client:
+            response = client.get(initial_url)
+
+            if response.status_code == 403:
+                console.print("[bold red]The owner of this website has banned your IP[/bold red]")
+                raise
+
+            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"\n[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.
+
+    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
+        with httpx.Client(
+            headers={
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
+                'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+                'User-Agent': get_headers()
+            },
+            follow_redirects=True,
+            timeout=max_timeout
+        ) as client:
+            response_follow = client.get(f"{base_url}.{domain}")
+            response_follow.raise_for_status()
+
+    except Exception as e:
+        query = base_url.split("/")[-1]
+        
+        # Perform a Google search with multiple results
+        search_results = list(search(query, num_results=10, lang="it"))
+        console.print(f"\nGoogle search results: {search_results}")
+
+        def normalize_for_comparison(url):
+            """Normalize URL by removing protocol, www, and trailing slashes"""
+            url = url.lower()
+            url = url.replace("https://", "").replace("http://", "")
+            url = url.replace("www.", "")
+            return url.rstrip("/")
+
+        # Normalize the base_url we're looking for
+        target_url = normalize_for_comparison(base_url)
+        
+        # Iterate through search results
+        for first_url in search_results:
+            console.print(f"[green]Checking url[white]: [red]{first_url}")
+            
+            # Get just the domain part of the search result
+            parsed_result = urlparse(first_url)
+            result_domain = normalize_for_comparison(parsed_result.netloc)
+            
+            # Compare with our target URL (without the protocol part)
+            if result_domain.startswith(target_url.split("/")[-1]):
+                try:
+                    final_url = get_final_redirect_url(first_url, max_timeout)
+
+                    if final_url is not None:
+                        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"\n[cyan]Do you want to auto update site[white] [red]'{site_name}'[cyan] with domain[white] [red]'{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 new_domain_extract, f"{base_url}.{new_domain_extract}"
+                
+                except Exception as redirect_error:
+                    console.print(f"[red]Error following redirect for {first_url}: {redirect_error}")
+                    continue
+
+        # If no matching URL is found
+        console.print("[bold red]No valid URL found matching the base URL.[/bold red]")
+        raise Exception("No matching domain found")
+
+    # Handle successful initial domain check
+    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}"