eaf-base-api 2.2.5__tar.gz → 2.2.7__tar.gz

{eaf_base_api-2.2.5 → eaf_base_api-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.2.5
+Version: 2.2.7
 Summary: A base API for EchterAlsFake's Porn APIs
 Home-page: https://github.com/EchterAlsFake/eaf_base_api
 Author: Johannes Habel
@@ -20,6 +20,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{eaf_base_api-2.2.5 → eaf_base_api-2.2.7}/base_api/base.py

@@ -1,12 +1,15 @@
+import re
 import os
+import sys
 import time
 import m3u8
+import json
 import httpx
 import random
-import string
 import logging
 import traceback
 import threading
+import http.client
 
 from typing import Union
 from functools import lru_cache
@@ -15,29 +18,137 @@ from ffmpeg_progress_yield import FfmpegProgress
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 try:
-    from modules import consts
+    from modules import config
     from modules.progress_bars import Callback
 
 except (ModuleNotFoundError, ImportError):
-    from .modules import consts
+    from .modules import config
     from .modules.progress_bars import Callback
 
-logging.basicConfig(format='%(name)s %(levelname)s %(asctime)s %(message)s', datefmt='%I:%M:%S %p')
-logger = logging.getLogger("BASE API")
-logger.setLevel(logging.DEBUG)
+loggers = {}
+
+# Default formatter
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+
+def is_android():
+    """Detects if the script is running on an Android device."""
+    return "ANDROID_ROOT" in os.environ and "ANDROID_DATA" in os.environ
+
+def get_log_file_path(filename="app.log"):
+    """Returns a valid log file path that works on Android and other OS."""
+    if is_android():
+        return os.path.join(os.environ["HOME"], filename)  # Internal app storage
+    return filename  # Default for Linux, Windows, Mac
+
+
+# Define ANSI color codes for different log levels
+LOG_COLORS = {
+    'DEBUG': "\033[37m",   # White
+    'INFO': "\033[34m",    # Blue
+    'WARNING': "\033[33m", # Yellow
+    'ERROR': "\033[31m",   # Red
+    'CRITICAL': "\033[41m"  # Red background
+}
+RESET_COLOR = "\033[0m"
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        log_message = super().format(record)
+        color = LOG_COLORS.get(record.levelname, RESET_COLOR)
+        return f"{color}{log_message}{RESET_COLOR}"
+
+
+def send_log_message(ip, port, message):
+    """Sends a log message to a remote server via HTTP."""
+    try:
+        conn = http.client.HTTPConnection(ip, port, timeout=2)
+        headers = {'Content-Type': 'application/json'}
+        data = json.dumps({"message": message})
+        conn.request("POST", "/log", body=data, headers=headers)
+        conn.getresponse()  # Read response to ensure completion
+        conn.close()
+    except Exception as e:
+        print(f"Failed to send log to {ip}:{port} - {e}", file=sys.stderr)
+
+
+class HTTPLogHandler(logging.Handler):
+    """Custom log handler that sends logs to a remote HTTP server."""
+
+    def __init__(self, ip, port):
+        super().__init__()
+        self.ip = ip
+        self.port = port
+
+    def emit(self, record):
+        log_entry = self.format(record)
+        send_log_message(self.ip, self.port, log_entry)
+
+
+def setup_logger(name, log_file=None, level=logging.CRITICAL, http_ip=None, http_port=None):
+    """Creates or updates a logger for a specific module."""
+    if name in loggers:
+        logger = loggers[name]
+        logger.setLevel(level)
+
+        file_handler_exists = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
+        http_handler_exists = any(isinstance(h, HTTPLogHandler) for h in logger.handlers)
+
+        if log_file and not file_handler_exists:
+            log_file = get_log_file_path(log_file)
+            fh = logging.FileHandler(log_file, mode='a')
+            fh.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+            logger.addHandler(fh)
+
+        if http_ip and http_port and not http_handler_exists:
+            http_handler = HTTPLogHandler(http_ip, http_port)
+            http_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+            logger.addHandler(http_handler)
+
+        return logger
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if not any(isinstance(h, logging.StreamHandler) for h in logger.handlers):
+        ch = logging.StreamHandler()
+        ch.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        logger.addHandler(ch)
+
+    if log_file:
+        log_file = get_log_file_path(log_file)
+        if not hasattr(sys, '_first_run'):
+            sys._first_run = True
+            file_mode = 'w'
+        else:
+            file_mode = 'a'
+        fh = logging.FileHandler(log_file, mode=file_mode)
+        fh.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        logger.addHandler(fh)
 
-def disable_logging():
-    logger.setLevel(logging.CRITICAL)
+    if http_ip and http_port:
+        http_handler = HTTPLogHandler(http_ip, http_port)
+        http_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        logger.addHandler(http_handler)
 
+    loggers[name] = logger
+    return logger
 
 class Cache:
     """
     Caches content from network requests
     """
 
-    def __init__(self):
+    def __init__(self, config):
         self.cache_dictionary = {}
         self.lock = threading.Lock()
+        self.logger = setup_logger("BASE API - [Cache]", level=logging.CRITICAL)
+
+    def enable_logging(self, log_file=None, level=logging.DEBUG):
+        """
+        Enables logging dynamically for this module.
+        """
+        self.logger = setup_logger(name="BASE API - [Cache]", log_file=log_file, level=level)
 
     def handle_cache(self, url):
         if url is None:
@@ -49,137 +160,191 @@ class Cache:
 
     def save_cache(self, url, content):
         with self.lock:
-            if len(self.cache_dictionary.keys()) >= consts.MAX_CACHE_ITEMS:
+            if len(self.cache_dictionary.keys()) >= config.config.MAX_CACHE_ITEMS:
                 first_key = next(iter(self.cache_dictionary))
                 # Delete the first item
                 del self.cache_dictionary[first_key]
-                logger.info(f"Deleting: {first_key} from cache, due to caching limits...")
+                self.logger.info(f"Deleting: {first_key} from cache, due to caching limits...")
 
             self.cache_dictionary[url] = content
 
-cache = Cache()
-
-
 class BaseCore:
     """
     The base class which has all necessary functions for other API packages
     """
-    def __init__(self):
+    def __init__(self, config=config.config):
         self.last_request_time = time.time()
         self.total_requests = 0 # Tracks how many requests have been made
         self.session = None
+        self.kill_switch = False
+        self.config = config
+        self.cache = Cache(self.config)
         self.initialize_session()
+        self.logger = setup_logger("BASE API - [BaseCore]", log_file=False, level=logging.ERROR)
 
+    def enable_logging(self, log_file=None, level=logging.DEBUG):
+        """
+        Enables logging dynamically for this module.
+        """
+        self.logger = setup_logger(name="BASE API - [BaseCore]", log_file=log_file, level=level)
+        self.cache.logger = setup_logger(name="BASE API - [Cache]", log_file=log_file, level=level)
 
     def update_user_agent(self):
         """Updates the User-Agent"""
-        self.session.headers.update({"User-Agent": random.choice(consts.USER_AGENTS)})
+        self.config.rotate_user_agent()
+        self.session.headers.update({"User-Agent": self.config.headers["User-Agent"]})
+
+    def enable_kill_switch(self):
+        """This is a function that will check and verify if your proxy is working before every request.
+        As soon as there's a mismatch in the actual response IP and the proxy IP, the program will exit."""
+        self.kill_switch = True
+
+    def check_kill_switch(self):
+        proxy_ip = self.config.PROXY
+        pattern = re.compile(
+            r'^(?P<scheme>http|socks5)://'
+            r'(?:(?:\w+:\w+)@)?'  # optional user:pass@
+            r'(?P<host>[a-zA-Z0-9.-]+)'
+            r':(?P<port>\d{1,5})$'
+        )
+
+        match = pattern.match(proxy_ip
+    )
+        if match:
+            self.logger.info(f"Proxy has valid scheme: {match.group('scheme')} ")
+
+        else:
+            self.logger.critical("Proxy is INVALID! Exiting.")
+
+        self.logger.info("Checking if proxy is working...")
+        self.logger.info("Doing request to httpbin.org to get your real IP to compare it with another request with activated proxy")
 
-    def initialize_session(self):
-        verify = True
+        your_ip = httpx.Client().get("https://httpbin.org/ip").json()["origin"]
+        self.logger.info(f"Your IP is: {your_ip}")
 
-        if consts.PROXY is not None:
-            verify = False
+        self.logger.info("Doing request with Proxy on...")
+        proxy_ip_ = self.fetch("https://httpbin.org/ip", bypass_kill_switch=True, get_response=True).json()["origin"]
+        self.logger.info(f"Proxy IP is: {proxy_ip_}")
 
-        self.session = httpx.Client(proxy=consts.PROXY,
-                              headers=consts.HEADERS,
-                              verify=verify,
-                              timeout=consts.TIMEOUT,
-                              follow_redirects=True)
+        if your_ip == proxy_ip_:
+            self.logger.critical("IP is the same on both requests... Proxy is not working, exiting!")
+            raise "CRITICAL PROXY ERROR, CHECK LOGS!"
+
+
+    def initialize_session(self, verify=True): # Disable SSL verification only if you really need it....
+        self.session = httpx.Client(
+            proxy=self.config.PROXY,
+            headers=self.config.HEADERS,
+            timeout=self.config.TIMEOUT,
+            follow_redirects=True,
+            verify=verify
+        )
 
     def enforce_delay(self):
         """Enforces the specified delay in consts.REQUEST_DELAY"""
-        delay = consts.REQUEST_DELAY
+        delay = self.config.REQUEST_DELAY
         if delay > 0:
             time_since_last_request = time.time() - self.last_request_time
-            logger.debug(f"Time since last request: {time_since_last_request:.2f} seconds.")
+            self.logger.debug(f"Time since last request: {time_since_last_request:.2f} seconds.")
             if time_since_last_request < delay:
                 sleep_time = delay - time_since_last_request
-                logger.debug(f"Enforcing delay of {sleep_time:.2f} seconds.")
+                self.logger.debug(f"Enforcing delay of {sleep_time:.2f} seconds.")
                 time.sleep(sleep_time)
 
     def fetch(
             self,
             url: str,
             get_bytes: bool = False,
-            timeout: int = consts.TIMEOUT,
+            timeout: int = None,
             get_response: bool = False,
             save_cache: bool = True,
             cookies: dict = None,
             allow_redirects: bool = True,
+            bypass_kill_switch: bool = False # prevents infinite loop
     ) -> Union[bytes, str, httpx.Response, None]:
         """
         Fetches content in UTF-8 Text, Bytes, or as a stream using multiple request attempts,
         support for proxies and custom timeout.
         """
         # Check cache first
-        content = cache.handle_cache(url)
-        if content is not None:
-            logger.info(f"Fetched content for: {url} from cache!")
+
+        if timeout is None:
+            timeout = self.config.timeout # pls don't ask thanks
+
+        content = self.cache.handle_cache(url)
+        if content:
+            self.logger.info(f"Fetched content for: {url} from cache!")
             return content
 
-        for attempt in range(1, consts.MAX_RETRIES + 1):
+        for attempt in range(1, self.config.MAX_RETRIES + 1):
             if attempt != 1:
                 time.sleep(1.5) # Sleeping for 1.5 seconds to minimize site overload when doing a lot of requests
 
             try:
                 # Update user agent periodically
-                if self.total_requests % 3 == 0:
+                if self.total_requests % 30 == 0: # Changing all 30 attempts
                     self.update_user_agent()
 
                 self.enforce_delay()
 
+                if self.kill_switch and not bypass_kill_switch:
+                    self.check_kill_switch()
+
                 # Perform the request with stream handling
-                with self.session.stream("GET", url, timeout=timeout, cookies=cookies,
-                                         follow_redirects=allow_redirects) as response:
-                    self.total_requests += 1
+                response = self.session.get(url, timeout=timeout, cookies=cookies,
+                                         follow_redirects=allow_redirects)
+                self.total_requests += 1
 
-                    # Log and handle non-200 status codes
-                    if response.status_code != 200:
-                        logger.warning(
-                            f"Attempt {attempt}: Unexpected status code {response.status_code} for URL: {url}")
+                # Log and handle non-200 status codes
+                if response.status_code != 200:
+                    self.logger.warning(
+                        f"Attempt {attempt}: Unexpected status code {response.status_code} for URL: {url}")
 
-                        if response.status_code == 404:
-                            logger.error("Resource not found (404). This may indicate the content is unavailable.")
-                            return None  # Return None for unavailable resources
+                    if response.status_code == 404:
+                        self.logger.error("Resource not found (404). This may indicate the content is unavailable.")
+                        return None  # Return None for unavailable resources
 
-                        continue  # Retry for other non-200 status codes
+                    elif response.status_code == 403 and attempt >= 2:
+                        self.logger.error(f"The website rejected access after {attempt} tries. Aborting!")
+                        return None # Return None for forbidden resources
 
-                    logger.debug(f"Attempt {attempt}: Successfully fetched URL: {url}")
+                    continue  # Retry for other non-200 status codes
 
-                    # Return response if requested
-                    if get_response:
-                        return response
+                self.logger.debug(f"Attempt {attempt}: Successfully fetched URL: {url}")
 
-                    # Process and return content
-                    # Collecting all chunks before processing because some sites cause issues with real-time decoding
-                    raw_content = b"".join(response.iter_bytes())
+                # Return response if requested
+                if get_response:
+                    return response
 
-                    if get_bytes:
-                        content = raw_content
+                # Process and return content
+                # Collecting all chunks before processing because some sites cause issues with real-time decoding
+                raw_content = response.content
 
-                    else:
-                        try:
-                            content = raw_content.decode("utf-8")
+                if get_bytes:
+                    content = raw_content
+
+                else:
+                    try:
+                        content = raw_content.decode("utf-8")
 
-                        except UnicodeDecodeError:
-                            content = raw_content.decode("latin1") # Fallback, hope that works somehow idk
+                    except UnicodeDecodeError:
+                        content = raw_content.decode("latin1") # Fallback, hope that works somehow idk
 
-                        if save_cache and not get_bytes:
-                            logger.debug(f"Saving content of {url} to local cache.")
-                            cache.save_cache(url, content)
+                    if save_cache and not get_bytes:
+                        self.logger.debug(f"Saving content of {url} to local cache.")
+                        self.cache.save_cache(url, content)
 
-                    return content
+                return content
 
             except httpx.RequestError as e:
-                logger.error(f"Attempt {attempt}: Request error for URL {url}: {e}")
+                self.logger.error(f"Attempt {attempt}: Request error for URL {url}: {e}")
 
             except Exception:
-                logger.error(f"Attempt {attempt}: Unexpected error for URL {url}: {traceback.format_exc()}")
+                self.logger.error(f"Attempt {attempt}: Unexpected error for URL {url}: {traceback.format_exc()}")
 
-            logger.info(f"Retrying ({attempt}/{consts.MAX_RETRIES}) for URL: {url}")
+            self.logger.info(f"Retrying ({attempt}/{self.config.MAX_RETRIES}) for URL: {url}")
 
-        logger.error(f"Failed to fetch URL {url} after {consts.MAX_RETRIES} attempts.")
+        self.logger.error(f"Failed to fetch URL {url} after {self.config.MAX_RETRIES} attempts.")
         return None  # Return None if all attempts fail
 
     @classmethod
@@ -188,9 +353,11 @@ class BaseCore:
         :param title:
         :return: str: strips out non UTF-8 chars of the title
         """
-        illegal_chars = '<>:"/\\|?*'
-        cleaned_title = ''.join([char for char in title if char in string.printable and char not in illegal_chars])
-        return cleaned_title
+        illegal_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
+        for char in illegal_chars:
+            title = title.replace(char, "")
+
+        return title
 
     @lru_cache(maxsize=250)
     def get_m3u8_by_quality(self, m3u8_url: str, quality: str) -> str:
@@ -198,7 +365,7 @@ class BaseCore:
         m3u8 playlist"""
         playlist_content = self.fetch(url=m3u8_url)
         playlist = m3u8.loads(playlist_content)
-        logger.debug(f"Resolved m3u8 playlist: {m3u8_url}")
+        self.logger.debug(f"Resolved m3u8 playlist: {m3u8_url}")
 
         if not playlist.is_variant:
             raise ValueError("Provided URL is not a master playlist.")
@@ -235,7 +402,7 @@ class BaseCore:
     def get_segments(self, m3u8_url_master: str, quality: str) -> list:
         """Gets all video segments from a given quality and the primary m3u8 URL"""
         m3u8_url = self.get_m3u8_by_quality(m3u8_url=m3u8_url_master, quality=quality)
-        logger.debug(f"Trying to fetch segment from m3u8 ->: {m3u8_url}")
+        self.logger.debug(f"Trying to fetch segment from m3u8 ->: {m3u8_url}")
         content = self.fetch(url=m3u8_url)
         segments_ = m3u8.loads(content).segments
         segments = []
@@ -243,7 +410,7 @@ class BaseCore:
         for segment in segments_:
             segments.append(urljoin(m3u8_url, segment.uri)) # Get the full URL path to segment
 
-        logger.debug(f"Fetched {len(segments)} segments from m3u8 URL")
+        self.logger.debug(f"Fetched {len(segments)} segments from m3u8 URL")
         return segments
 
     def download(self, video, quality: str, downloader: str, path: str, callback=None) -> None:
@@ -269,14 +436,13 @@ class BaseCore:
         elif downloader == "FFMPEG":
             self.FFMPEG(video=video, quality=quality, path=path, callback=callback)
 
-    @classmethod
-    def download_segment(cls, url: str, timeout: int) -> tuple[str, bytes, bool]:
+    def download_segment(self, url: str, timeout: int) -> tuple[str, bytes, bool]:
         """
         Attempt to download a single segment, retrying on failure.
         Returns a tuple of the URL, content (empty if failed after retries), and a success flag.
         """
 
-        content = BaseCore().fetch(url, timeout=timeout, get_bytes=True)
+        content = self.fetch(url, timeout=timeout, get_bytes=True)
         return url, content, True  # Success
 
     def threaded(self, max_workers: int = 20, timeout: int = 10):
@@ -307,7 +473,7 @@ class BaseCore:
                             successful_downloads += 1
                         callback(completed, length)  # Update progress callback
                     except Exception as e:
-                        logger.error(f"Error processing segment {hls_part}: {e}")
+                        self.logger.error(f"Error processing segment {hls_part}: {e}")
 
             # Write only successful segments to the output file
             with open(path, 'wb') as file:
@@ -323,7 +489,7 @@ class BaseCore:
                             if success:
                                 file.write(data)
                         except Exception as e:
-                            logger.error(f"Exception writing segment {segment_url}: {e}")
+                            self.logger.error(f"Exception writing segment {segment_url}: {e}")
 
         return wrapper
 
@@ -354,7 +520,7 @@ class BaseCore:
 
         # Build the command for FFMPEG as a list directly
         command = [
-            consts.FFMPEG_PATH,
+            self.config.FFMPEG_PATH,
             "-i", new_url,  # Input URL
             "-bsf:a", "aac_adtstoasc",
             "-y",  # Overwrite output files without asking
@@ -408,10 +574,10 @@ class BaseCore:
                 return True
 
         except httpx.RequestError as e:
-            logger.error(f"Request failed for URL {url}: {e}")
+            self.logger.error(f"Request failed for URL {url}: {e}")
             return False
         except Exception as e:
-            logger.error(f"Unexpected error during download: {e}")
+            self.logger.error(f"Unexpected error during download: {e}")
             return False
 
     @classmethod

eaf_base_api-2.2.7/base_api/modules/config.py

@@ -0,0 +1,36 @@
+import random
+
+class RuntimeConfig:
+    def __init__(self):
+        self.max_cache_items = 200
+        self.max_retries = 4
+        self.request_delay = 0
+        self.timeout = 20
+        self.ffmpeg_path = "ffmpeg"
+        self.proxy = None
+        self.verify_ssl = True
+        self.user_agents = [
+            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.1",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.3",
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.3",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0."
+        ]
+        self.cookies = None
+        self.headers = {
+            "User-Agent": random.choice(self.user_agents)
+        }
+
+    def rotate_user_agent(self):
+        self.headers["User-Agent"] = random.choice(self.user_agents)
+
+    def as_httpx_kwargs(self):
+        return {
+            "proxies": self.proxy,
+            "verify": self.verify_ssl,
+            "headers": self.headers,
+            "timeout": self.timeout
+        }
+
+# Singleton instance needed for my Porn Fetch project
+config = RuntimeConfig()

{eaf_base_api-2.2.5 → eaf_base_api-2.2.7}/eaf_base_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.2.5
+Version: 2.2.7
 Summary: A base API for EchterAlsFake's Porn APIs
 Home-page: https://github.com/EchterAlsFake/eaf_base_api
 Author: Johannes Habel
@@ -20,6 +20,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{eaf_base_api-2.2.5 → eaf_base_api-2.2.7}/eaf_base_api.egg-info/SOURCES.txt

@@ -4,7 +4,7 @@ setup.py
 base_api/__init__.py
 base_api/base.py
 base_api/modules/__init__.py
-base_api/modules/consts.py
+base_api/modules/config.py
 base_api/modules/progress_bars.py
 eaf_base_api.egg-info/PKG-INFO
 eaf_base_api.egg-info/SOURCES.txt

{eaf_base_api-2.2.5 → eaf_base_api-2.2.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="eaf_base_api",
-    version="2.2.5",
+    version="2.2.7",
     packages=find_packages(),
     install_requires=["ffmpeg-progress-yield", "m3u8", "httpx"],
     entry_points={

eaf_base_api-2.2.5/base_api/modules/consts.py

@@ -1,16 +0,0 @@
-import random
-
-MAX_CACHE_ITEMS = 200 # Lower this value if you are on a low-ram system (<=4 GB)
-MAX_RETRIES = 4
-REQUEST_DELAY = 0
-TIMEOUT = 20 # Maximal request timeout
-FFMPEG_PATH = "ffmpeg"
-PROXY = None
-USER_AGENTS = ["Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-           "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.1",
-           "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.3",
-           "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.3",
-           "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0."]
-
-HEADERS = {"User-Agent": random.choice(USER_AGENTS)}
-COOKIES = None