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

StreamingCommunity/Api/Player/Helper/Vixcloud/js_parser.py

@@ -0,0 +1,143 @@
+# 26.11.24
+# !!! DIO CANErino
+
+import re
+
+
+class JavaScriptParser:
+    @staticmethod
+    def fix_string(ss):
+        if ss is None:
+            return None
+        
+        ss = str(ss)
+        ss = ss.encode('utf-8').decode('unicode-escape')
+        ss = ss.strip("\"'")
+        ss = ss.strip()
+        
+        return ss
+    
+    @staticmethod
+    def fix_url(url):
+        if url is None:
+            return None
+
+        url = url.replace('\\/', '/')
+        return url
+
+    @staticmethod
+    def parse_value(value):
+        value = JavaScriptParser.fix_string(value)
+
+        if 'http' in str(value) or 'https' in str(value):
+            return JavaScriptParser.fix_url(value)
+        
+        if value is None or str(value).lower() == 'null':
+            return None
+        if str(value).lower() == 'true':
+            return True
+        if str(value).lower() == 'false':
+            return False
+        
+        try:
+            return int(value)
+        except ValueError:
+            try:
+                return float(value)
+            except ValueError:
+                pass
+        
+        return value
+
+    @staticmethod
+    def parse_object(obj_str):
+        obj_str = obj_str.strip('{}').strip()
+        
+        result = {}
+        key_value_pairs = re.findall(r'([\'"]?[\w]+[\'"]?)\s*:\s*([^,{}]+|{[^}]*}|\[[^\]]*\]|\'[^\']*\'|"[^"]*")', obj_str)
+        
+        for key, value in key_value_pairs:
+            key = JavaScriptParser.fix_string(key)
+            value = value.strip()
+
+            if value.startswith('{'):
+                result[key] = JavaScriptParser.parse_object(value)
+            elif value.startswith('['):
+                result[key] = JavaScriptParser.parse_array(value)
+            else:
+                result[key] = JavaScriptParser.parse_value(value)
+        
+        return result
+
+    @staticmethod
+    def parse_array(arr_str):
+        arr_str = arr_str.strip('[]').strip()
+        result = []
+        
+        elements = []
+        current_elem = ""
+        brace_count = 0
+        in_string = False
+        quote_type = None
+
+        for char in arr_str:
+            if char in ['"', "'"]:
+                if not in_string:
+                    in_string = True
+                    quote_type = char
+                elif quote_type == char:
+                    in_string = False
+                    quote_type = None
+            
+            if not in_string:
+                if char == '{':
+                    brace_count += 1
+                elif char == '}':
+                    brace_count -= 1
+                elif char == ',' and brace_count == 0:
+                    elements.append(current_elem.strip())
+                    current_elem = ""
+                    continue
+            
+            current_elem += char
+        
+        if current_elem.strip():
+            elements.append(current_elem.strip())
+        
+        for elem in elements:
+            elem = elem.strip()
+            
+            if elem.startswith('{'):
+                result.append(JavaScriptParser.parse_object(elem))
+            elif 'active' in elem or 'url' in elem:
+                key_value_match = re.search(r'([\w]+)\":([^,}]+)', elem)
+
+                if key_value_match:
+                    key = key_value_match.group(1)
+                    value = key_value_match.group(2)
+                    result[-1][key] = JavaScriptParser.parse_value(value.strip('"\\'))
+            else:
+                result.append(JavaScriptParser.parse_value(elem))
+        
+        return result
+
+    @classmethod
+    def parse(cls, js_string):
+        assignments = re.findall(r'window\.(\w+)\s*=\s*([^;]+);?', js_string, re.DOTALL)
+        result = {}
+        
+        for var_name, value in assignments:
+            value = value.strip()
+            
+            if value.startswith('{'):
+                result[var_name] = cls.parse_object(value)
+            elif value.startswith('['):
+                result[var_name] = cls.parse_array(value)
+            else:
+                result[var_name] = cls.parse_value(value)
+        
+        can_play_fhd_match = re.search(r'window\.canPlayFHD\s*=\s*(\w+);?', js_string)
+        if can_play_fhd_match:
+            result['canPlayFHD'] = cls.parse_value(can_play_fhd_match.group(1))
+        
+        return result

StreamingCommunity/Api/Player/Helper/Vixcloud/util.py

@@ -0,0 +1,136 @@
+# 23.11.24
+
+from typing import Dict, Any, List, Union
+
+
+class Episode:
+    def __init__(self, data: Dict[str, Any]):
+        self.data = data
+
+        self.id: int = data.get('id', 0)
+        self.scws_id: int = data.get('scws_id', 0)
+        self.number: int = data.get('number', 1)
+        self.name: str = data.get('name', '')
+        self.plot: str = data.get('plot', '')
+        self.duration: int = data.get('duration', 0)
+
+    def __str__(self):
+        return f"Episode(id={self.id}, number={self.number}, name='{self.name}', plot='{self.plot}', duration={self.duration} sec)"
+
+class EpisodeManager:
+    def __init__(self):
+        self.episodes: List[Episode] = []
+
+    def add(self, episode_data: Dict[str, Any]):
+        """
+        Add a new episode to the manager.
+
+        Parameters:
+            - episode_data (Dict[str, Any]): A dictionary containing data for the new episode.
+        """
+        episode = Episode(episode_data)
+        self.episodes.append(episode)
+
+    def get(self, index: int) -> Episode:
+        """
+        Retrieve an episode by its index in the episodes list.
+
+        Parameters:
+            - index (int): The zero-based index of the episode to retrieve.
+
+        Returns:
+            Episode: The Episode object at the specified index.
+        """
+        return self.episodes[index]
+    
+    def length(self) -> int:
+        """
+        Get the number of episodes in the manager.
+
+        Returns:
+            int: Number of episodes.
+        """
+        return len(self.episodes)
+    
+    def clear(self) -> None:
+        """
+        This method clears the episodes list.
+
+        Parameters:
+            - self: The object instance.
+        """
+        self.episodes.clear()
+
+    def __str__(self):
+        return f"EpisodeManager(num_episodes={len(self.episodes)})"
+
+
+class Season:
+    def __init__(self, season_data: Dict[str, Union[int, str, None]]):
+        self.season_data = season_data
+
+        self.id: int = season_data.get('id', 0)
+        self.scws_id: int = season_data.get('scws_id', 0)
+        self.imdb_id: int = season_data.get('imdb_id', 0)
+        self.number: int = season_data.get('number', 0)
+        self.name: str = season_data.get('name', '')
+        self.slug: str = season_data.get('slug', '')
+        self.plot: str = season_data.get('plot', '')
+        self.type: str = season_data.get('type', '')
+        self.seasons_count: int = season_data.get('seasons_count', 0)
+        self.episodes: EpisodeManager = EpisodeManager()
+        
+
+class Stream:
+    def __init__(self, name: str, url: str, active: bool):
+        self.name = name
+        self.url = url
+        self.active = active
+
+    def __repr__(self):
+        return f"Stream(name={self.name!r}, url={self.url!r}, active={self.active!r})"
+
+class StreamsCollection:
+    def __init__(self, streams: list):
+        self.streams = [Stream(**stream) for stream in streams]
+
+    def __repr__(self):
+        return f"StreamsCollection(streams={self.streams})"
+
+    def add_stream(self, name: str, url: str, active: bool):
+        self.streams.append(Stream(name, url, active))
+
+    def get_streams(self):
+        return self.streams
+
+    
+class WindowVideo:
+    def __init__(self, data: Dict[str, Any]):
+        self.data = data
+        self.id: int = data.get('id', '')
+        self.name: str = data.get('name', '')
+        self.filename: str = data.get('filename', '')
+        self.size: str = data.get('size', '')
+        self.quality: str = data.get('quality', '')
+        self.duration: str = data.get('duration', '')
+        self.views: int = data.get('views', '')
+        self.is_viewable: bool = data.get('is_viewable', '')
+        self.status: str = data.get('status', '')
+        self.fps: float = data.get('fps', '')
+        self.legacy: bool = data.get('legacy', '')
+        self.folder_id: int = data.get('folder_id', '')
+        self.created_at_diff: str = data.get('created_at_diff', '')
+
+    def __str__(self):
+        return f"WindowVideo(id={self.id}, name='{self.name}', filename='{self.filename}', size='{self.size}', quality='{self.quality}', duration='{self.duration}', views={self.views}, is_viewable={self.is_viewable}, status='{self.status}', fps={self.fps}, legacy={self.legacy}, folder_id={self.folder_id}, created_at_diff='{self.created_at_diff}')"
+
+class WindowParameter:
+    def __init__(self, data: Dict[str, Any]):
+        self.data = data
+        params = data.get('params', {})
+        self.token: str = params.get('token', '')
+        self.expires: str = str(params.get('expires', ''))
+        self.url = data.get('url')
+
+    def __str__(self):
+        return (f"WindowParameter(token='{self.token}', expires='{self.expires}', url='{self.url}', data={self.data})")

StreamingCommunity/Api/Player/ddl.py

@@ -0,0 +1,89 @@
+# 14.06.24
+
+import logging
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.headers import get_headers
+
+
+# Variable
+from StreamingCommunity.Api.Site.ddlstreamitaly.costant import COOKIE
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+class VideoSource:
+    def __init__(self) -> None:
+        """
+        Initializes the VideoSource object with default values.
+        """
+        self.headers = {'user-agent': get_headers()}
+        self.cookie = COOKIE
+
+    def setup(self, url: str) -> None:
+        """
+        Sets up the video source with the provided URL.
+
+        Parameters:
+            - url (str): The URL of the video source.
+        """
+        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 = httpx.get(
+                url=url, 
+                headers=self.headers, 
+                cookies=self.cookie,
+                timeout=max_timeout
+            )
+            response.raise_for_status()
+
+            return response.text
+        
+        except Exception as err:
+            logging.error(f"An error occurred: {err}")
+
+        return None
+
+    def get_playlist(self):
+        """
+        Retrieves the playlist URL from the video source.
+
+        Returns:
+            - tuple: The mp4 link if found, None otherwise.
+        """
+        try:
+            text = self.make_request(self.url)
+
+            if text:
+                soup = BeautifulSoup(text, "html.parser")
+                source = soup.find("source")
+
+                if source:
+                    mp4_link = source.get("src")
+                    return mp4_link
+            
+                else:
+                    logging.error("No <source> tag found in the HTML.")
+                    
+            else:
+                logging.error("Failed to retrieve content from the URL.")
+
+        except Exception as e:
+            logging.error(f"An error occurred while parsing the playlist: {e}")

StreamingCommunity/Api/Player/maxstream.py

@@ -0,0 +1,151 @@
+# 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()