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

StreamingCommunity/Api/Player/maxstream.py

@@ -1,151 +0,0 @@
-# 05.07.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):
-        """
-        Sets up the video source with the provided URL.
-
-        Parameters:
-            - url (str): The URL of the video.
-        """
-        self.url = url
-        self.redirect_url = None
-        self.maxstream_url = None
-        self.m3u8_url = None
-        self.headers = {'user-agent': get_headers()}
-
-    def get_redirect_url(self):
-        """
-        Sends a request to the initial URL and extracts the redirect URL.
-        """
-        try:
-
-            # Send a GET request to the initial URL
-            response = httpx.get(self.url, headers=self.headers, follow_redirects=True, timeout=max_timeout)
-            response.raise_for_status()
-
-            # Extract the redirect URL from the HTML
-            soup = BeautifulSoup(response.text, "html.parser")
-            self.redirect_url = soup.find("div", id="iframen1").get("data-src")
-            logging.info(f"Redirect URL: {self.redirect_url}")
-
-            return self.redirect_url
-        
-        except httpx.RequestError as e:
-            logging.error(f"Error during the initial request: {e}")
-            raise
-
-        except AttributeError as e:
-            logging.error(f"Error parsing HTML: {e}")
-            raise
-
-    def get_maxstream_url(self):
-        """
-        Sends a request to the redirect URL and extracts the Maxstream URL.
-        """
-        try:
-
-            # Send a GET request to the redirect URL
-            response = httpx.get(self.redirect_url, headers=self.headers, follow_redirects=True, timeout=max_timeout)
-            response.raise_for_status()
-
-            # Extract the Maxstream URL from the HTML
-            soup = BeautifulSoup(response.text, "html.parser")
-            maxstream_url = soup.find("a")
-            
-            if maxstream_url is None:
-
-                # If no anchor tag is found, try the alternative method
-                logging.warning("Anchor tag not found. Trying the alternative method.")
-                headers = {
-                    'origin': 'https://stayonline.pro',
-                    'user-agent': get_headers(),
-                    'x-requested-with': 'XMLHttpRequest',
-                }
-
-                # Make request to stayonline api
-                data = {'id': self.redirect_url.split("/")[-2], 'ref': ''}
-                response = httpx.post('https://stayonline.pro/ajax/linkEmbedView.php', headers=headers, data=data)
-                response.raise_for_status()
-                uprot_url = response.json()['data']['value']
-
-                # Retry getting maxtstream url
-                response = httpx.get(uprot_url, headers=self.headers, follow_redirects=True, timeout=max_timeout)
-                response.raise_for_status()
-                soup = BeautifulSoup(response.text, "html.parser")
-                maxstream_url = soup.find("a").get("href")
-                
-            else:
-                maxstream_url = maxstream_url.get("href")
-
-            self.maxstream_url = maxstream_url
-            logging.info(f"Maxstream URL: {self.maxstream_url}")
-
-            return self.maxstream_url
-        
-        except httpx.RequestError as e:
-            logging.error(f"Error during the request to the redirect URL: {e}")
-            raise
-
-        except AttributeError as e:
-            logging.error(f"Error parsing HTML: {e}")
-            raise
-
-    def get_m3u8_url(self):
-        """
-        Sends a request to the Maxstream URL and extracts the .m3u8 file URL.
-        """
-        try:
-            
-            # Send a GET request to the Maxstream URL
-            response = httpx.get(self.maxstream_url, headers=self.headers, follow_redirects=True, timeout=max_timeout)
-            response.raise_for_status() 
-            soup = BeautifulSoup(response.text, "html.parser")
-
-            # Iterate over all script tags in the HTML
-            for script in soup.find_all("script"):
-                if "eval(function(p,a,c,k,e,d)" in script.text:
-
-                    # Execute the script using
-                    data_js = jsbeautifier.beautify(script.text)
-
-                    # Extract the .m3u8 URL from the script's output
-                    match = re.search(r'sources:\s*\[\{\s*src:\s*"([^"]+)"', data_js)
-
-                    if match:
-                        self.m3u8_url = match.group(1)
-                        logging.info(f"M3U8 URL: {self.m3u8_url}")
-                        break
-
-            return self.m3u8_url
-
-        except Exception as e:
-            logging.error(f"Error executing the Node.js script: {e}")
-            raise
-
-    def get_playlist(self):
-        """
-        Executes the entire flow to obtain the final .m3u8 file URL.
-        """
-        self.get_redirect_url()
-        self.get_maxstream_url()
-        return self.get_m3u8_url()

StreamingCommunity/Api/Player/supervideo.py

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

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

@@ -1,51 +0,0 @@
-# 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 [green]{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

@@ -1,15 +0,0 @@
-# 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')