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

StreamingCommunity/Api/Player/supervideo.py

@@ -0,0 +1,194 @@
+# 26.05.24
+
+import re
+import logging
+
+
+# External libraries
+import httpx
+import jsbeautifier
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.headers import get_headers
+
+
+# Variable
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+class VideoSource:
+    def __init__(self, url: str) -> None:
+        """
+        Initializes the VideoSource object with default values.
+
+        Attributes:
+            - url (str): The URL of the video source.
+        """
+        self.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()
+        }
+        self.client = httpx.Client()
+        self.url = url
+
+    def make_request(self, url: str) -> str:
+        """
+        Make an HTTP GET request to the provided URL.
+
+        Parameters:
+            - url (str): The URL to make the request to.
+
+        Returns:
+            - str: The response content if successful, None otherwise.
+        """
+
+        try:
+            response = self.client.get(
+                url=url, 
+                headers=self.headers, 
+                follow_redirects=True, 
+                timeout=max_timeout
+            )
+            response.raise_for_status()
+            return response.text
+        
+        except Exception as e:
+            logging.error(f"Request failed: {e}")
+            return None
+
+    def parse_html(self, html_content: str) -> BeautifulSoup:
+        """
+        Parse the provided HTML content using BeautifulSoup.
+
+        Parameters:
+            - html_content (str): The HTML content to parse.
+
+        Returns:
+            - BeautifulSoup: Parsed HTML content if successful, None otherwise.
+        """
+
+        try:
+            soup = BeautifulSoup(html_content, "html.parser")
+            return soup
+        
+        except Exception as e:
+            logging.error(f"Failed to parse HTML content: {e}")
+            return None
+        
+    def get_iframe(self, soup):
+        """
+        Extracts the source URL of the second iframe in the provided BeautifulSoup object.
+
+        Parameters:
+            - soup (BeautifulSoup): A BeautifulSoup object representing the parsed HTML.
+
+        Returns:
+            - str: The source URL of the second iframe, or None if not found.
+        """
+        iframes = soup.find_all("iframe")
+        if iframes and len(iframes) > 1:
+            return iframes[1].get("src")
+        
+        return None
+
+    def find_content(self, url):
+        """
+        Makes a request to the specified URL and parses the HTML content.
+
+        Parameters:
+            - url (str): The URL to fetch content from.
+
+        Returns:
+            - BeautifulSoup: A BeautifulSoup object representing the parsed HTML content, or None if the request fails.
+        """
+        content = self.make_request(url)
+        if content:
+            return self.parse_html(content)
+        
+        return None
+        
+    def get_result_node_js(self, soup):
+        """
+        Prepares and runs a Node.js script from the provided BeautifulSoup object to retrieve the video URL.
+
+        Parameters:
+            - soup (BeautifulSoup): A BeautifulSoup object representing the parsed HTML content.
+
+        Returns:
+            - str: The output from the Node.js script, or None if the script cannot be found or executed.
+        """
+        for script in soup.find_all("script"):
+            if "eval" in str(script):
+                return jsbeautifier.beautify(script.text)
+            
+        return None
+
+    def get_playlist(self) -> str:
+        """
+        Download a video from the provided URL.
+
+        Returns:
+            str: The URL of the downloaded video if successful, None otherwise.
+        """
+        try:
+            html_content = self.make_request(self.url)
+            if not html_content:
+                logging.error("Failed to fetch HTML content.")
+                return None
+
+            soup = self.parse_html(html_content)
+            if not soup:
+                logging.error("Failed to parse HTML content.")
+                return None
+
+            # Find master playlist
+            data_js = self.get_result_node_js(soup)
+
+            if data_js is not None:
+                match = re.search(r'sources:\s*\[\{\s*file:\s*"([^"]+)"', data_js)
+
+                if match:
+                    return match.group(1)
+                    
+            else:
+
+                iframe_src = self.get_iframe(soup)
+                if not iframe_src:
+                    logging.error("No iframe found.")
+                    return None
+
+                down_page_soup = self.find_content(iframe_src)
+                if not down_page_soup:
+                    logging.error("Failed to fetch down page content.")
+                    return None
+
+                pattern = r'data-link="(//supervideo[^"]+)"'
+                match = re.search(pattern, str(down_page_soup))
+                if not match:
+                    logging.error("No player available for download.")
+                    return None
+
+                supervideo_url = "https:" + match.group(1)
+                supervideo_soup = self.find_content(supervideo_url)
+                if not supervideo_soup:
+                    logging.error("Failed to fetch supervideo content.")
+                    return None
+
+                # Find master playlist
+                data_js = self.get_result_node_js(supervideo_soup)
+
+                match = re.search(r'sources:\s*\[\{\s*file:\s*"([^"]+)"', data_js)
+
+                if match:
+                    return match.group(1)
+            
+            return None
+
+        except Exception as e:
+            logging.error(f"An error occurred: {e}")
+            return None
+        

StreamingCommunity/Api/Player/vixcloud.py

@@ -0,0 +1,273 @@
+# 01.03.24
+
+import sys
+import logging
+from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util._jsonConfig import config_manager
+from .Helper.Vixcloud.util import WindowVideo, WindowParameter, StreamsCollection
+from .Helper.Vixcloud.js_parser import JavaScriptParser
+
+
+# Variable
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+class VideoSource:
+    def __init__(self, site_name: str,  is_series: bool):
+        """
+        Initialize video source for streaming site.
+        
+        Args:
+            site_name (str): Name of streaming site
+            is_series (bool): Flag for series or movie content
+        """
+        self.headers = {'user-agent': get_headers()}
+        self.base_name = site_name
+        self.domain = config_manager.get_dict('SITE', self.base_name)['domain']
+        self.is_series = is_series
+
+    def setup(self, media_id: int):
+        """
+        Configure media-specific context.
+        
+        Args:
+            media_id (int): Unique identifier for media item
+        """
+        self.media_id = media_id
+
+    def get_iframe(self, episode_id: int) -> None:
+        """
+        Retrieve iframe source for specified episode.
+        
+        Args:
+            episode_id (int): Unique identifier for episode
+        """
+        params = {}
+
+        if self.is_series:
+            params = {
+                'episode_id': episode_id, 
+                'next_episode': '1'
+            }
+
+        try:
+
+            # Make a request to get iframe source
+            response = httpx.get(
+                url=f"https://{self.base_name}.{self.domain}/iframe/{self.media_id}", 
+                params=params, 
+                timeout=max_timeout
+            )
+            response.raise_for_status()
+
+            # Parse response with BeautifulSoup to get iframe source
+            soup = BeautifulSoup(response.text, "html.parser")
+            self.iframe_src = soup.find("iframe").get("src")
+
+        except Exception as e:
+            logging.error(f"Error getting iframe source: {e}")
+            raise
+
+    def parse_script(self, script_text: str) -> None:
+        """
+        Convert raw script to structured video metadata.
+        
+        Args:
+            script_text (str): Raw JavaScript/HTML script content
+        """
+        try:
+            converter = JavaScriptParser.parse(js_string=str(script_text))
+
+            # Create window video, streams and parameter objects
+            self.canPlayFHD = bool(converter.get('canPlayFHD'))
+            self.window_video = WindowVideo(converter.get('video'))
+            self.window_streams = StreamsCollection(converter.get('streams'))
+            self.window_parameter = WindowParameter(converter.get('masterPlaylist'))
+
+        except Exception as e:
+            logging.error(f"Error parsing script: {e}")
+            raise
+
+    def get_content(self) -> None:
+        """
+        Fetch and process video content from iframe source.
+        
+        Workflow:
+            - Validate iframe source
+            - Retrieve content
+            - Parse embedded script
+        """
+        try:
+            if self.iframe_src is not None:
+
+                # Make a request to get content
+                try:
+                    response = httpx.get(
+                        url=self.iframe_src, 
+                        headers=self.headers, 
+                        timeout=max_timeout
+                    )
+                    response.raise_for_status()
+
+                except Exception as e:
+                    logging.error(f"Failed to get vixcloud contente with error: {e}")
+                    sys.exit(0)
+
+                # Parse response with BeautifulSoup to get content
+                soup = BeautifulSoup(response.text, "html.parser")
+                script = soup.find("body").find("script").text
+
+                # Parse script to get video information
+                self.parse_script(script_text=script)
+
+        except Exception as e:
+            logging.error(f"Error getting content: {e}")
+            raise
+
+    def get_playlist(self) -> str:
+        """
+        Generate authenticated playlist URL.
+
+        Returns:
+            str: Fully constructed playlist URL with authentication parameters
+        """
+        # Initialize parameters dictionary
+        params = {}
+
+        # Add 'h' parameter if video quality is 1080p
+        if self.canPlayFHD:
+            params['h'] = 1
+
+        # Parse the original URL
+        parsed_url = urlparse(self.window_parameter.url)
+        query_params = parse_qs(parsed_url.query)
+
+        # Check specifically for 'b=1' in the query parameters
+        if 'b' in query_params and query_params['b'] == ['1']:
+            params['b'] = 1
+
+        # Add authentication parameters (token and expiration)
+        params.update({
+            "token": self.window_parameter.token,
+            "expires": self.window_parameter.expires
+        })
+
+        # Build the updated query string
+        query_string = urlencode(params)
+
+        # Construct the new URL with updated query parameters
+        return urlunparse(parsed_url._replace(query=query_string))
+
+    def get_mp4(self, url_to_download: str, scws_id: str) -> list:
+        """
+        Generate download links for the specified resolutions from StreamingCommunity.
+        
+        Args:
+            url_to_download (str): URL of the video page.
+            scws_id (str): SCWS ID of the title.
+        
+        Returns:
+            list: A list of video download URLs.
+        """
+        headers = {
+            'referer': url_to_download,
+            'user-agent': get_headers(),
+        }
+
+        # API request to get video details
+        video_api_url = f'https://{self.base_name}.{self.domain}/api/video/{scws_id}'
+        response = httpx.get(video_api_url, headers=headers)
+
+        if response.status_code == 200:
+            response_json = response.json()
+
+            video_tracks = response_json.get('video_tracks', [])
+            track = video_tracks[-1]
+            console.print(f"[cyan]Available resolutions: [red]{[str(track['quality']) for track in video_tracks]}")
+
+            # Request download link generation for each track
+            download_response = httpx.post(
+                url=f'https://{self.base_name}.{self.domain}/api/download/generate_link?scws_id={track["video_id"]}&rendition={track["quality"]}',
+                headers={
+                    'referer': url_to_download,
+                    'user-agent': get_headers(),
+                    'x-xsrf-token': config_manager.get("SITE", self.base_name)['extra']['x-xsrf-token']
+                },
+                cookies={
+                    'streamingcommunity_session': config_manager.get("SITE", self.base_name)['extra']['streamingcommunity_session']
+                }
+            )
+
+            if download_response.status_code == 200:
+                return {'url': download_response.text, 'quality': track["quality"]}
+
+            else:
+                logging.error(f"Failed to generate link for resolution {track['quality']} (HTTP {download_response.status_code}).")
+
+        else:
+            logging.error(f"Error fetching video API URL (HTTP {response.status_code}).")
+            return []
+
+
+class VideoSourceAnime(VideoSource):
+    def __init__(self, site_name: str):
+        """
+        Initialize anime-specific video source.
+        
+        Args:
+            site_name (str): Name of anime streaming site
+        
+        Extends base VideoSource with anime-specific initialization
+        """
+        self.headers = {'user-agent': get_headers()}
+        self.base_name = site_name
+        self.domain = config_manager.get_dict('SITE', self.base_name)['domain']
+        self.src_mp4 = None
+
+    def get_embed(self, episode_id: int):
+        """
+        Retrieve embed URL and extract video source.
+        
+        Args:
+            episode_id (int): Unique identifier for episode
+        
+        Returns:
+            str: Parsed script content
+        """
+        try:
+
+            response = httpx.get(
+                url=f"https://www.{self.base_name}.{self.domain}/embed-url/{episode_id}", 
+                headers=self.headers, 
+                timeout=max_timeout
+            )
+            response.raise_for_status()
+
+            # Extract and clean embed URL
+            embed_url = response.text.strip()
+            self.iframe_src = embed_url
+
+            # Fetch video content using embed URL
+            video_response = httpx.get(embed_url)
+            video_response.raise_for_status()
+
+            # Parse response with BeautifulSoup to get content of the scriot
+            soup = BeautifulSoup(video_response.text, "html.parser")
+            script = soup.find("body").find("script").text
+            self.src_mp4 = soup.find("body").find_all("script")[1].text.split(" = ")[1].replace("'", "")
+
+            return script
+        
+        except Exception as e:
+            logging.error(f"Error fetching embed URL: {e}")
+            return None

StreamingCommunity/Api/Site/1337xx/__init__.py

@@ -0,0 +1,51 @@
+# 02.07.24
+
+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 = 8
+_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 [red]{SITE_NAME}").strip()
+    
+    # Search on database
+    len_database = 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/1337xx/costant.py

@@ -0,0 +1,15 @@
+# 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 = config_manager.get('DEFAULT', 'serie_folder_name')
+MOVIE_FOLDER = config_manager.get('DEFAULT', 'movie_folder_name')

StreamingCommunity/Api/Site/1337xx/site.py

@@ -0,0 +1,86 @@
+# 02.07.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
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+
+
+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
+    max_timeout = config_manager.get_int("REQUESTS", "timeout")
+    domain_to_use, _ = search_domain(SITE_NAME, f"https://{SITE_NAME}")
+
+    # Construct the full site URL and load the search page
+    try:
+        response = httpx.get(
+            url=f"https://{SITE_NAME}.{domain_to_use}/search/{word_to_search}/1/", 
+            headers={'user-agent': get_headers()}, 
+            follow_redirects=True,
+            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")
+
+    # Scrape div film in table on single page
+    for tr in soup.find_all('tr'):
+        try:
+
+            title_info = {
+                'name': tr.find_all("a")[1].get_text(strip=True),
+                'url': tr.find_all("a")[1].get("href"),
+                'seader': tr.find_all("td")[-5].get_text(strip=True),
+                'leacher': tr.find_all("td")[-4].get_text(strip=True),
+                'date': tr.find_all("td")[-3].get_text(strip=True).replace("'", ""),
+                'size': tr.find_all("td")[-2].get_text(strip=True)
+            }
+            
+            media_search_manager.add_media(title_info)
+
+        except:
+            continue
+
+    # 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/1337xx/title.py

@@ -0,0 +1,66 @@
+# 02.07.24
+
+import os
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Lib.Downloader import TOR_downloader
+
+
+# Logic class
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Config
+from .costant import ROOT_PATH, DOMAIN_NOW, SITE_NAME, 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_manager.get_sanitize_path(
+        os.path.join(ROOT_PATH, MOVIE_FOLDER, title_name.replace(".mp4", ""))
+    )
+    
+    # Create output folder
+    os_manager.create_path(mp4_path)                                                                    
+
+    # Make request to page with magnet
+    full_site_name = f"{SITE_NAME}.{DOMAIN_NOW}"
+    response = httpx.get(
+        url="https://" + full_site_name + select_title.url, 
+        headers={
+            'user-agent': get_headers()
+        }, 
+        follow_redirects=True
+    )
+
+    # Create soup and find table
+    soup = BeautifulSoup(response.text, "html.parser")
+    final_url = soup.find("a", class_="torrentdown1").get("href")
+
+    # Tor manager
+    manager = TOR_downloader()
+    manager.add_magnet_link(final_url)
+    manager.start_download()
+    manager.move_downloaded_files(mp4_path)