eaf-base-api 2.2.6__tar.gz → 2.2.8__tar.gz

{eaf_base_api-2.2.6 → eaf_base_api-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.2.6
+Version: 2.2.8
 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.6 → eaf_base_api-2.2.8}/base_api/base.py

@@ -1,12 +1,14 @@
+import re
 import os
 import sys
 import time
 import m3u8
+import json
 import httpx
-import random
 import logging
 import traceback
 import threading
+import http.client
 
 from typing import Union
 from functools import lru_cache
@@ -15,11 +17,11 @@ 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
 
 loggers = {}
@@ -56,19 +58,52 @@ class ColoredFormatter(logging.Formatter):
         return f"{color}{log_message}{RESET_COLOR}"
 
 
-def setup_logger(name, log_file=None, level=logging.CRITICAL):
+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)
@@ -76,10 +111,9 @@ def setup_logger(name, log_file=None, level=logging.CRITICAL):
 
     if not any(isinstance(h, logging.StreamHandler) for h in logger.handlers):
         ch = logging.StreamHandler()
-        ch.setFormatter(ColoredFormatter("%(asctime)s - %(levelname)s - %(message)s"))
+        ch.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
         logger.addHandler(ch)
 
-    # Ensure the log file is overwritten only on the first program start
     if log_file:
         log_file = get_log_file_path(log_file)
         if not hasattr(sys, '_first_run'):
@@ -87,11 +121,15 @@ def setup_logger(name, log_file=None, level=logging.CRITICAL):
             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)
 
+    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
 
@@ -100,10 +138,11 @@ 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)
+        self.config = config
 
     def enable_logging(self, log_file=None, level=logging.DEBUG):
         """
@@ -121,7 +160,7 @@ 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()) >= self.config.max_cache_items:
                 first_key = next(iter(self.cache_dictionary))
                 # Delete the first item
                 del self.cache_dictionary[first_key]
@@ -133,11 +172,13 @@ 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.cache = Cache()
+        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)
 
@@ -150,23 +191,58 @@ class BaseCore:
 
     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')} ")
 
-    def initialize_session(self):
-        verify = True
+        else:
+            self.logger.critical("Proxy is INVALID! Exiting.")
 
-        if consts.PROXY is not None:
-            verify = False
+        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")
 
-        self.session = httpx.Client(proxy=consts.PROXY,
-                              headers=consts.HEADERS,
-                              verify=verify,
-                              timeout=consts.TIMEOUT,
-                              follow_redirects=True)
+        your_ip = httpx.Client().get("https://httpbin.org/ip").json()["origin"]
+        self.logger.info(f"Your IP is: {your_ip}")
+
+        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_}")
+
+        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
             self.logger.debug(f"Time since last request: {time_since_last_request:.2f} seconds.")
@@ -179,78 +255,86 @@ class BaseCore:
             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
+
+        if timeout is None:
+            timeout = self.config.timeout # pls don't ask thanks
+
         content = self.cache.handle_cache(url)
-        if content is not None:
+        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 % 5 == 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:
-                        self.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:
-                            self.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
 
-                        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
+                    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
 
-                        continue  # Retry for other non-200 status codes
+                    continue  # Retry for other non-200 status codes
 
-                    self.logger.debug(f"Attempt {attempt}: Successfully fetched URL: {url}")
+                self.logger.debug(f"Attempt {attempt}: Successfully fetched URL: {url}")
 
-                    # Return response if requested
-                    if get_response:
-                        return response
+                # Return response if requested
+                if get_response:
+                    return response
 
-                    # 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())
+                # Process and return content
+                # Collecting all chunks before processing because some sites cause issues with real-time decoding
+                raw_content = response.content
 
-                    if get_bytes:
-                        content = raw_content
+                if get_bytes:
+                    content = raw_content
 
-                    else:
-                        try:
-                            content = raw_content.decode("utf-8")
+                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:
-                            self.logger.debug(f"Saving content of {url} to local cache.")
-                            self.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:
                 self.logger.error(f"Attempt {attempt}: Request error for URL {url}: {e}")
@@ -258,9 +342,9 @@ class BaseCore:
             except Exception:
                 self.logger.error(f"Attempt {attempt}: Unexpected error for URL {url}: {traceback.format_exc()}")
 
-            self.logger.info(f"Retrying ({attempt}/{consts.MAX_RETRIES}) for URL: {url}")
+            self.logger.info(f"Retrying ({attempt}/{self.config.max_retries}) for URL: {url}")
 
-        self.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
@@ -352,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):
@@ -437,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

eaf_base_api-2.2.8/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.6 → eaf_base_api-2.2.8}/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.6
+Version: 2.2.8
 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.6 → eaf_base_api-2.2.8}/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.6 → eaf_base_api-2.2.8}/setup.py

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

eaf_base_api-2.2.6/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