StreamingCommunity 1.7.6__py3-none-any.whl

StreamingCommunity/Src/Util/_jsonConfig.py

@@ -0,0 +1,204 @@
+# 29.01.24
+
+import os
+import json
+import httpx
+import logging
+from typing import Any, List
+
+
+class ConfigManager:
+    def __init__(self, file_path: str = 'config.json') -> None:
+        """Initialize the ConfigManager.
+
+        Parameters:
+            - file_path (str, optional): The path to the configuration file. Default is 'config.json'.
+        """
+        self.file_path = file_path
+        self.config = {}
+        self.cache = {}
+
+    def read_config(self) -> None:
+        """Read the configuration file."""
+        try:
+            logging.info(f"Reading file: {self.file_path}")
+            
+            # Check if file exist
+            if os.path.exists(self.file_path):
+                with open(self.file_path, 'r') as f:
+                    self.config = json.load(f)
+                logging.info("Configuration file loaded successfully.")
+            
+            # Download config.json
+            else:
+                logging.info("Configuration file does not exist. Downloading...")
+                url = "https://raw.githubusercontent.com/Lovi-0/StreamingCommunity/refs/heads/main/config.json"
+                
+                with httpx.Client() as client:
+                    response = client.get(url)
+                    
+                    if response.status_code == 200:
+                        with open(self.file_path, 'w') as f:
+                            f.write(response.text)
+
+                        self.config = json.loads(response.text)
+                        logging.info("Configuration file downloaded and saved.")
+
+                    else:
+                        logging.error(f"Failed to download configuration file. Status code: {response.status_code}")
+        
+        except Exception as e:
+            logging.error(f"Error reading configuration file: {e}")
+
+    def read_key(self, section: str, key: str, data_type: type = str) -> Any:
+        """Read a key from the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be read.
+            - data_type (type, optional): The expected data type of the key's value. Default is str.
+
+        Returns:
+            The value of the key converted to the specified data type.
+        """
+        cache_key = f"{section}.{key}"
+        logging.info(f"Read key: {cache_key}")
+
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+        
+        if section in self.config and key in self.config[section]:
+            value = self.config[section][key]
+        else:
+            raise ValueError(f"Key '{key}' not found in section '{section}'")
+        
+        value = self._convert_to_data_type(value, data_type)
+        self.cache[cache_key] = value
+        
+        return value
+
+    def _convert_to_data_type(self, value: str, data_type: type) -> Any:
+        """Convert the value to the specified data type.
+
+        Parameters:
+            - value (str): The value to be converted.
+            - data_type (type): The expected data type.
+
+        Returns:
+            The value converted to the specified data type.
+        """
+        if data_type == int:
+            return int(value)
+        elif data_type == bool:
+            return bool(value)
+        elif data_type == list:
+            return value if isinstance(value, list) else [item.strip() for item in value.split(',')]
+        elif data_type == type(None):
+            return None
+        else:
+            return value
+        
+    def get(self, section: str, key: str) -> Any:
+        """Read a value from the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be read.
+
+        Returns:
+            The value associated with the key.
+        """
+        return self.read_key(section, key)
+
+    def get_int(self, section: str, key: str) -> int:
+        """Read an integer value from the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be read.
+
+        Returns:
+            int: The integer value.
+        """
+        return self.read_key(section, key, int)
+    
+    def get_float(self, section: str, key: str) -> int:
+        """Read an float value from the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be read.
+
+        Returns:
+            float: The float value.
+        """
+        return self.read_key(section, key, float)
+
+    def get_bool(self, section: str, key: str) -> bool:
+        """Read a boolean value from the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be read.
+
+        Returns:
+            bool: The boolean value.
+        """
+        return self.read_key(section, key, bool)
+
+    def get_list(self, section: str, key: str) -> List[str]:
+        """Read a list value from the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be read.
+
+        Returns:
+            list: The list value.
+        """
+        return self.read_key(section, key, list)
+    
+    def get_dict(self, section: str, key: str) -> dict:
+        """Read a dictionary value from the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be read.
+
+        Returns:
+            dict: The dictionary value.
+        """
+        return self.read_key(section, key, dict)
+
+    def set_key(self, section: str, key: str, value: Any) -> None:
+        """Set a key in the configuration file.
+
+        Parameters:
+            - section (str): The section in the configuration file.
+            - key (str): The key to be set.
+            - value (Any): The value to be associated with the key.
+        """
+        try:
+            if section not in self.config:
+                self.config[section] = {}
+
+            self.config[section][key] = value
+            cache_key = f"{section}.{key}"
+            self.cache[cache_key] = value
+            self.write_config()
+
+        except Exception as e:
+            print(f"Error setting key '{key}' in section '{section}': {e}")
+
+    def write_config(self) -> None:
+        """Write the configuration to the file."""
+        try:
+            with open(self.file_path, 'w') as f:
+                json.dump(self.config, f, indent=4)
+        except Exception as e:
+            print(f"Error writing configuration file: {e}")
+            
+
+# Initialize
+config_manager = ConfigManager()
+config_manager.read_config()

StreamingCommunity/Src/Util/call_stack.py

@@ -0,0 +1,42 @@
+# 21.06.24
+
+import os
+import inspect
+
+
+def get_call_stack():
+    """
+    Retrieves the current call stack with details about each call.
+
+    This function inspects the current call stack and returns a list of dictionaries,
+    where each dictionary contains details about a function call in the stack.
+
+    Returns:
+        list: A list of dictionaries, each containing the following keys:
+            - function (str): The name of the function.
+            - folder (str): The directory path of the script containing the function.
+            - folder_base (str): The base name of the directory path.
+            - script (str): The name of the script file containing the function.
+            - line (int): The line number in the script where the function is defined.
+    """
+    
+    stack = inspect.stack()
+    call_stack = []
+
+    for frame_info in stack:
+        function_name = frame_info.function
+        filename = frame_info.filename
+        lineno = frame_info.lineno
+        folder_name = os.path.dirname(filename)
+        folder_base = os.path.basename(folder_name)
+        script_name = os.path.basename(filename)
+
+        call_stack.append({
+            "function": function_name,
+            "folder": folder_name,
+            "folder_base": folder_base,
+            "script": script_name,
+            "line": lineno
+        })
+        
+    return call_stack

StreamingCommunity/Src/Util/color.py

@@ -0,0 +1,20 @@
+# 24.05.24
+
+class Colors:
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    LIGHT_GRAY = "\033[37m"
+    DARK_GRAY = "\033[90m"
+    LIGHT_RED = "\033[91m"
+    LIGHT_GREEN = "\033[92m"
+    LIGHT_YELLOW = "\033[93m"
+    LIGHT_BLUE = "\033[94m"
+    LIGHT_MAGENTA = "\033[95m"
+    LIGHT_CYAN = "\033[96m"
+    WHITE = "\033[97m"
+    RESET = "\033[0m"

StreamingCommunity/Src/Util/console.py

@@ -0,0 +1,12 @@
+# 24.02.24
+
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+
+# Variable
+msg = Prompt()
+console = Console()

StreamingCommunity/Src/Util/headers.py

@@ -0,0 +1,147 @@
+# 4.04.24
+
+import re
+import random
+
+
+# External library
+from fake_useragent import UserAgent
+
+
+# Variable
+ua = UserAgent()
+
+
+def extract_versions(user_agent):
+    """
+    Extract browser versions from the user agent.
+
+    Parameters:
+        user_agent (str): User agent of the browser.
+
+    Returns:
+        list: List of browser versions.
+    """
+
+    # Patterns to extract versions from various user agents
+    patterns = {
+        'chrome': re.compile(r'Chrome/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
+        'firefox': re.compile(r'Firefox/(\d+)\.?(\d+)?\.?(\d+)?'),
+        'safari': re.compile(r'Version/(\d+)\.(\d+)\.(\d+) Safari/(\d+)\.(\d+)\.(\d+)'),
+        'edge': re.compile(r'Edg/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
+        'edgios': re.compile(r'EdgiOS/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
+        'crios': re.compile(r'CriOS/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
+    }
+
+    for key, pattern in patterns.items():
+        match = pattern.search(user_agent)
+        if match:
+            return [match.group(i+1) for i in range(match.lastindex)]
+
+    # Fallback values if specific versions are not found
+    return ['99', '0', '0', '0']
+
+def get_platform(user_agent):
+    """
+    Determine the device platform from the user agent.
+
+    Parameters:
+        user_agent (str): User agent of the browser.
+
+    Returns:
+        str: Device platform.
+    """
+    if 'Windows' in user_agent:
+        return '"Windows"'
+    elif 'Mac OS X' in user_agent:
+        return '"macOS"'
+    elif 'Android' in user_agent:
+        return '"Android"'
+    elif 'iPhone' in user_agent or 'iPad' in user_agent:
+        return '"iOS"'
+    elif 'Linux' in user_agent:
+        return '"Linux"'
+    return '"Unknown"'
+
+def get_model(user_agent):
+    """
+    Determine the device model from the user agent.
+
+    Parameters:
+        user_agent (str): User agent of the browser.
+
+    Returns:
+        str: Device model.
+    """
+    if 'iPhone' in user_agent:
+        return '"iPhone"'
+    elif 'iPad' in user_agent:
+        return '"iPad"'
+    elif 'Android' in user_agent:
+        return '"Android"'
+    elif 'Windows' in user_agent:
+        return '"PC"'
+    elif 'Mac OS X' in user_agent:
+        return '"Mac"'
+    elif 'Linux' in user_agent:
+        return '"Linux"'
+    return '"Unknown"'
+
+def random_headers(referer: str = None):
+    """
+    Generate random HTTP headers to simulate human-like behavior.
+
+    Returns:
+        dict: Generated HTTP headers.
+    """
+    user_agent = ua.random
+    versions = extract_versions(user_agent)
+    platform = get_platform(user_agent)
+    model = get_model(user_agent)
+    is_mobile = 'Mobi' in user_agent or 'Android' in user_agent
+
+    # Generate sec-ch-ua string based on the browser
+    if 'Chrome' in user_agent or 'CriOS' in user_agent:
+        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Chromium";v="{versions[0]}", "Google Chrome";v="{versions[0]}"'
+    elif 'Edg' in user_agent or 'EdgiOS' in user_agent:
+        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Chromium";v="{versions[0]}", "Microsoft Edge";v="{versions[0]}"'
+    elif 'Firefox' in user_agent:
+        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Firefox";v="{versions[0]}"'
+    elif 'Safari' in user_agent:
+        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Safari";v="{versions[0]}"'
+    else:
+        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}"'
+
+    headers = {
+        'User-Agent': user_agent,
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+        'Accept-Language': random.choice(['en-US', 'en-GB', 'fr-FR', 'es-ES', 'de-DE']),
+        'Accept-Encoding': 'gzip, deflate, br',
+        'Connection': 'keep-alive',
+        'Upgrade-Insecure-Requests': '1',
+        'Sec-Fetch-Dest': 'document',
+        'Sec-Fetch-Mode': 'navigate',
+        'Sec-Fetch-Site': 'none',
+        'Sec-Fetch-User': '?1',
+        'sec-ch-ua-mobile': '?1' if is_mobile else '?0',
+        'sec-ch-ua-platform': platform,
+        'sec-ch-ua': sec_ch_ua,
+        'sec-ch-ua-model': model
+    }
+
+    if referer:
+        headers['Origin'] = referer
+        headers['Referer'] = referer
+    
+    return headers
+
+def get_headers() -> str:
+    """
+    Generate a random user agent to use in HTTP requests.
+
+    Returns:
+        - str: A random user agent string.
+    """
+    
+    # Get a random user agent string from the user agent rotator
+    return str(ua.chrome)

StreamingCommunity/Src/Util/logger.py

@@ -0,0 +1,53 @@
+# 26.03.24
+
+import logging
+from logging.handlers import RotatingFileHandler
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+
+
+class Logger:
+    def __init__(self):
+
+        # Fetching configuration values
+        self.DEBUG_MODE = config_manager.get_bool("DEFAULT", "debug")
+        self.log_to_file = config_manager.get_bool("DEFAULT", "log_to_file")
+        self.log_file = config_manager.get("DEFAULT", "log_file") if self.log_to_file else None
+
+        logging.getLogger("httpx").setLevel(logging.WARNING)
+        logging.getLogger("httpcore").setLevel(logging.WARNING)
+
+        
+        # Setting logging level based on DEBUG_MODE
+        if self.DEBUG_MODE:
+            logging.getLogger('root').setLevel(logging.DEBUG)
+
+            # Configure file logging if debug mode and logging to file are both enabled
+            if self.log_to_file:
+                self.configure_file_logging()
+        else:
+
+            # If DEBUG_MODE is False, set logging level to ERROR
+            logging.getLogger('root').setLevel(logging.ERROR)
+
+        # Configure console logging
+        self.configure_logging()
+
+    def configure_logging(self):
+        """
+        Configure console logging.
+        """
+        logging.basicConfig(level=logging.DEBUG, format='[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
+
+    def configure_file_logging(self):
+        """
+        Configure file logging if enabled.
+        """
+
+        file_handler = RotatingFileHandler(self.log_file, maxBytes=10*1024*1024, backupCount=5)
+        file_handler.setLevel(logging.DEBUG)
+        formatter = logging.Formatter('[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
+        file_handler.setFormatter(formatter)
+        logging.getLogger('').addHandler(file_handler)

StreamingCommunity/Src/Util/message.py

@@ -0,0 +1,46 @@
+# 3.12.23
+
+import os
+import platform
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+
+
+# Variable
+CLEAN = config_manager.get_bool('DEFAULT', 'clean_console')
+SHOW = config_manager.get_bool('DEFAULT', 'show_message')
+
+
+def start_message():
+    """
+    Display a start message.
+    """
+
+    msg = r'''
+
+   _____ _                            _                _____                                      _ _         
+  / ____| |                          (_)              / ____|                                    (_) |        
+ | (___ | |_ _ __ ___  __ _ _ __ ___  _ _ __   __ _  | |     ___  _ __ ___  _ __ ___  _   _ _ __  _| |_ _   _ 
+  \___ \| __| '__/ _ \/ _` | '_ ` _ \| | '_ \ / _` | | |    / _ \| '_ ` _ \| '_ ` _ \| | | | '_ \| | __| | | |
+  ____) | |_| | |  __/ (_| | | | | | | | | | | (_| | | |___| (_) | | | | | | | | | | | |_| | | | | | |_| |_| |
+ |_____/ \__|_|  \___|\__,_|_| |_| |_|_|_| |_|\__, |  \_____\___/|_| |_| |_|_| |_| |_|\__,_|_| |_|_|\__|\__, |
+                                               __/ |                                                     __/ |
+                                              |___/                                                     |___/ 
+
+    '''
+
+    if CLEAN: 
+        if platform.system() == 'Windows':
+            os.system("cls")
+        else:
+            os.system("clear")
+    
+    if SHOW:
+        console.print(f"[bold yellow]{msg}")
+        console.print(f"[magenta]Created by: Lovi\n")
+
+        row = "-" * console.width
+        console.print(f"[yellow]{row} \n")