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

StreamingCommunity/Util/headers.py

@@ -0,0 +1,160 @@
+# 4.04.24
+
+import re
+import sys
+import random
+from importlib.metadata import version, PackageNotFoundError
+
+
+# External library
+from fake_useragent import UserAgent
+
+
+# Variable
+try:
+    ua_version = version('fake-useragent')
+except PackageNotFoundError:
+    ua_version = None
+
+if not getattr(sys, 'frozen', False):
+    if ua_version == '1.1.3':
+        ua = UserAgent(use_external_data=True)
+    else:
+        ua = UserAgent()
+else:
+    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/Util/logger.py

@@ -0,0 +1,62 @@
+# 26.03.24
+
+import os
+import logging
+from logging.handlers import RotatingFileHandler
+
+
+# Internal utilities
+from StreamingCommunity.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.remove_existing_log_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)
+
+    def remove_existing_log_file(self):
+        """
+        Remove the log file if it already exists.
+        """
+        if os.path.exists(self.log_file):
+            os.remove(self.log_file)

StreamingCommunity/Util/message.py

@@ -0,0 +1,64 @@
+# 3.12.23
+
+import os
+import platform
+
+# Internal utilities
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util._jsonConfig import config_manager
+
+# Variable
+CLEAN = config_manager.get_bool('DEFAULT', 'clean_console')
+SHOW = config_manager.get_bool('DEFAULT', 'show_message')
+
+
+def create_italian_flag_colored_text(text: str) -> str:
+    """Create text divided into three sections with Italian flag colors, splitting each line at two spaces."""
+    
+    # Split the text into lines
+    lines = text.splitlines()
+
+    colored_lines = []
+
+    for line in lines:
+        # Split each line into parts using two spaces as a delimiter
+        parts = line.split("       ")
+        
+        # Ensure there are exactly 3 parts (add empty strings if necessary)
+        parts += [''] * (4 - len(parts))
+
+        # Apply flag colors to the parts
+        green_part = f"[green]{parts[0]}[/]"
+        white_part = f"[white]{parts[1]}[/]"
+        red_part = f"[red]{parts[2]}[/]"
+
+        # Reassemble the colored line
+        colored_line = green_part + white_part + red_part
+        colored_lines.append(colored_line)
+
+    # Join all colored lines back into a single string
+    return "\n".join(colored_lines)
+
+def start_message():
+    """Display a stylized start message in the console."""
+    
+    msg = r'''
+    ██╗      ██████╗ ██╗   ██╗██╗        ██╗  ██╗        ███████╗████████╗██████╗ ███████╗ █████╗ ███╗   ███╗██╗███╗   ██╗ ██████╗
+    ██║     ██╔═══██╗██║   ██║██║        ╚██╗██╔╝        ██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔══██╗████╗ ████║██║████╗  ██║██╔════╝
+    ██║     ██║   ██║██║   ██║██║         ╚███╔╝         ███████╗   ██║   ██████╔╝█████╗  ███████║██╔████╔██║██║██╔██╗ ██║██║  ███╗
+    ██║     ██║   ██║╚██╗ ██╔╝██║         ██╔██╗         ╚════██║   ██║   ██╔══██╗██╔══╝  ██╔══██║██║╚██╔╝██║██║██║╚██╗██║██║   ██║
+    ███████╗╚██████╔╝ ╚████╔╝ ██║        ██╔╝ ██╗        ███████║   ██║   ██║  ██║███████╗██║  ██║██║ ╚═╝ ██║██║██║ ╚████║╚██████╔╝
+    ╚══════╝ ╚═════╝   ╚═══╝  ╚═╝        ╚═╝  ╚═╝        ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝ ╚═════╝ 
+    '''.rstrip()
+
+    colored_msg = create_italian_flag_colored_text(msg)
+
+    if CLEAN: 
+        os.system("cls" if platform.system() == 'Windows' else "clear")
+    
+    if SHOW:
+        console.print(colored_msg)
+
+        # Print a decorative separator line using asterisks
+        separator = "_" * (console.width - 2)  # Ridotto di 2 per il padding
+        console.print(f"[yellow]{separator}[/yellow]\n")