eaf-base-api 2.2.9__tar.gz → 2.3.2__tar.gz

{eaf_base_api-2.2.9/eaf_base_api.egg-info → eaf_base_api-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.2.9
+Version: 2.3.2
 Summary: A base API for EchterAlsFake's Porn APIs
 Home-page: https://github.com/EchterAlsFake/eaf_base_api
 Author: Johannes Habel

{eaf_base_api-2.2.9 → eaf_base_api-2.3.2}/base_api/base.py

@@ -3,12 +3,10 @@ import os
 import sys
 import time
 import m3u8
-import json
 import httpx
 import logging
 import traceback
 import threading
-import http.client
 
 from typing import Union
 from functools import lru_cache
@@ -17,10 +15,12 @@ from ffmpeg_progress_yield import FfmpegProgress
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 try:
+    from modules.errors import *
     from modules.config import config
     from modules.progress_bars import Callback
 
 except (ModuleNotFoundError, ImportError):
+    from .modules.errors import *
     from .modules.config import config
     from .modules.progress_bars import Callback
 
@@ -59,14 +59,11 @@ class ColoredFormatter(logging.Formatter):
 
 
 def send_log_message(ip, port, message):
-    """Sends a log message to a remote server via HTTP."""
+    """Sends a log message to a remote server via HTTP or HTTPS."""
     try:
-        conn = http.client.HTTPConnection(ip, port, timeout=5)
-        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()
+        url = f"https://{ip}:{port}/feedback"
+        with httpx.Client(timeout=5) as client:
+            client.post(url, json={"message": message})
     except Exception as e:
         print(f"Failed to send log to {ip}:{port} - {e}", file=sys.stderr)
 
@@ -152,7 +149,7 @@ class Cache:
 
     def handle_cache(self, url):
         if url is None:
-            return
+            return None
 
         with self.lock:
             content = self.cache_dictionary.get(url, None)
@@ -194,6 +191,10 @@ class BaseCore:
         self.config.rotate_user_agent()
         self.session.headers.update({"User-Agent": self.config.headers["User-Agent"]})
 
+    def update_cookies(self):
+        """Updates cookies dynamically"""
+        self.session.cookies.update(self.config.cookies)
+
     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."""
@@ -215,6 +216,7 @@ class BaseCore:
 
         else:
             self.logger.critical("Proxy is INVALID! Exiting.")
+            raise InvalidProxy("The Proxy is invalid, all requests will be aborted, please check your configuration!")
 
         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")
@@ -228,7 +230,7 @@ class BaseCore:
 
         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!"
+            raise KillSwitch("CRITICAL PROXY ERROR, CHECK LOGS!")
 
 
     def initialize_session(self, verify=True): # Disable SSL verification only if you really need it....
@@ -240,6 +242,9 @@ class BaseCore:
             verify=verify
         )
 
+    def update_headers(self, headers: dict):
+        self.session.headers.update(headers)
+
     def enforce_delay(self):
         """Enforces the specified delay in consts.REQUEST_DELAY"""
         delay = self.config.request_delay
@@ -250,6 +255,7 @@ class BaseCore:
                 sleep_time = delay - time_since_last_request
                 self.logger.debug(f"Enforcing delay of {sleep_time:.2f} seconds.")
                 time.sleep(sleep_time)
+        self.last_request_time = time.time()
 
     def fetch(
             self,
@@ -260,7 +266,9 @@ class BaseCore:
             save_cache: bool = True,
             cookies: dict = None,
             allow_redirects: bool = True,
-            bypass_kill_switch: bool = False # prevents infinite loop
+            bypass_kill_switch: bool = False, # prevents infinite loop
+            data: dict = None,
+            method: str = "GET",
     ) -> Union[bytes, str, httpx.Response, None]:
         """
         Fetches content in UTF-8 Text, Bytes, or as a stream using multiple request attempts,
@@ -276,9 +284,9 @@ class BaseCore:
             self.logger.info(f"Fetched content for: {url} from cache!")
             return content
 
-        for attempt in range(1, self.config.max_retries + 1):
+        for attempt in range(1, self.config.max_retries + 1): # +1 because I feel like it
             if attempt != 1:
-                time.sleep(1.5) # Sleeping for 1.5 seconds to minimize site overload when doing a lot of requests
+                time.sleep(1.5 * attempt) # Sleeping for 1.5 seconds to minimize site overload when doing a lot of requests
 
             try:
                 # Update user agent periodically
@@ -291,8 +299,8 @@ class BaseCore:
                     self.check_kill_switch()
 
                 # Perform the request with stream handling
-                response = self.session.get(url, timeout=timeout, cookies=cookies,
-                                         follow_redirects=allow_redirects)
+                response = self.session.request(method=method, url=url, timeout=timeout, cookies=cookies,
+                                     follow_redirects=allow_redirects, data=data)
                 self.total_requests += 1
 
                 # Log and handle non-200 status codes
@@ -301,13 +309,14 @@ class BaseCore:
                         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.")
+                        self.logger.error(f"URL: {url} 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
 
+                    self.logger.info(f"Retrying ({attempt}/{self.config.max_retries}) for URL: {url}")
                     continue  # Retry for other non-200 status codes
 
                 self.logger.debug(f"Attempt {attempt}: Successfully fetched URL: {url}")
@@ -328,6 +337,7 @@ class BaseCore:
                         content = raw_content.decode("utf-8")
 
                     except UnicodeDecodeError:
+                        self.logger.warning(f"Content could not be decoded as utf-8 ({url}), decoding in 'latin1' instead!")
                         content = raw_content.decode("latin1") # Fallback, hope that works somehow idk
 
                     if save_cache and not get_bytes:
@@ -336,36 +346,78 @@ class BaseCore:
 
                 return content
 
+            except httpx.CloseError:
+                self.logger.error(f"Attempt {attempt}: The connection has been unexpectedly closed by: {url}. Retrying...")
+                continue
+
             except httpx.RequestError as e:
                 self.logger.error(f"Attempt {attempt}: Request error for URL {url}: {e}")
+                self.logger.info(f"Retrying ({attempt}/{self.config.max_retries}) for URL: {url}")
+                continue # Continuing even failed requests, because they may succeed on another try (maybe idk)
+
+            except (httpx.TimeoutException, httpx.ConnectTimeout) as e:
+                self.logger.error(f"Attempt {attempt}: Timeout error for URL {url}: {e}. Please increase your timeout in "
+                                  f"the configuration options to prevent that, or get a stable internet connection ;)")
+                self.logger.info(f"Retrying ({attempt}/{self.config.max_retries}) for URL: {url}")
+                continue
+
+            except httpx.CookieConflict as e:
+                self.logger.error(f"Some cookies are conflicting. Connection aborted! Please report this error immediately -->: {e}")
+                sys.exit(1)
+
+            except httpx.ProxyError as e:
+                self.logger.error(f"Proxy Error, please switch to another Proxy, it seems to be bad -->: {e}")
+                raise KillSwitch("Proxy error when trying a request, Aborting!")
 
             except Exception:
                 self.logger.error(f"Attempt {attempt}: Unexpected error for URL {url}: {traceback.format_exc()}")
-
-            self.logger.info(f"Retrying ({attempt}/{self.config.max_retries}) for URL: {url}")
+                raise UnknownError(f"Unexpected error for URL {url}: {traceback.format_exc()}")
 
         self.logger.error(f"Failed to fetch URL {url} after {self.config.max_retries} attempts.")
         return None  # Return None if all attempts fail
 
     @classmethod
-    def strip_title(cls, title: str) -> str:
+    def strip_title(cls, title: str, max_length: int = 255) -> str:
         """
-        :param title:
-        :return: str: strips out non UTF-8 chars of the title
+        Sanitize a filename to be safe across Windows, macOS, Linux, and Android.
+        Replaces or strips illegal characters and trims to a safe length.
         """
-        illegal_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
-        for char in illegal_chars:
-            title = title.replace(char, "")
 
-        return title
+        # Reserved characters on Windows + `/` for Unix/macOS
+        illegal_chars = r'[<>:"/\\|?*\x00-\x1F]'
+        sanitized = re.sub(illegal_chars, "_", title)
+
+        # Strip invisible zero-width characters
+        sanitized = re.sub(r'[\u200B-\u200D\uFEFF]', '', sanitized)
+
+        # Strip trailing periods or spaces (Windows)
+        sanitized = sanitized.rstrip(" .")
+
+        # Prevent reserved Windows filenames
+        reserved_names = {
+            "CON", "PRN", "AUX", "NUL",
+            *(f"COM{i}" for i in range(1, 10)),
+            *(f"LPT{i}" for i in range(1, 10)),
+        }
+        name_only = sanitized.split('.')[0].upper()
+        if name_only in reserved_names:
+            sanitized = f"_{sanitized}"
+
+        # Trim to max length
+        return sanitized[:max_length]
 
     @lru_cache(maxsize=250)
     def get_m3u8_by_quality(self, m3u8_url: str, quality: str) -> str:
         """Fetches the m3u8 URL for a given quality by extracting all possible sub-m3u8 URLs from the primary
         m3u8 playlist"""
-        playlist_content = self.fetch(url=m3u8_url)
-        playlist = m3u8.loads(playlist_content)
-        self.logger.debug(f"Resolved m3u8 playlist: {m3u8_url}")
+        if "#" in m3u8_url:
+            playlist = m3u8.loads(m3u8_url)
+            self.logger.debug("Resolved custom m3u8")
+
+        else:
+            playlist_content = self.fetch(url=m3u8_url)
+            playlist = m3u8.loads(playlist_content)
+            self.logger.debug(f"Resolved m3u8 playlist: {m3u8_url}")
 
         if not playlist.is_variant:
             raise ValueError("Provided URL is not a master playlist.")
@@ -404,12 +456,17 @@ class BaseCore:
         m3u8_url = self.get_m3u8_by_quality(m3u8_url=m3u8_url_master, quality=quality)
         self.logger.debug(f"Trying to fetch segment from m3u8 ->: {m3u8_url}")
         content = self.fetch(url=m3u8_url)
-        segments_ = m3u8.loads(content).segments
-        segments = []
 
-        for segment in segments_:
-            segments.append(urljoin(m3u8_url, segment.uri)) # Get the full URL path to segment
+        m3u8_processed = m3u8.loads(content)
 
+        if m3u8_processed.is_variant:
+            self.logger.warning("The M3U8 Playlist is not a media playlist. Trying to resolve to the first m3u8...")
+            new_m3u8 = urljoin(m3u8_url, m3u8_processed.playlists[0].uri)
+            self.logger.info(f"Resolved to new URL: {new_m3u8}")
+            content = self.fetch(url=new_m3u8)
+            m3u8_processed = m3u8.loads(content)
+
+        segments = [urljoin(m3u8_url, seg.uri) for seg in m3u8_processed.segments]
         self.logger.debug(f"Fetched {len(segments)} segments from m3u8 URL")
         return segments
 
@@ -474,6 +531,7 @@ class BaseCore:
                         callback(completed, length)  # Update progress callback
                     except Exception as e:
                         self.logger.error(f"Error processing segment {hls_part}: {e}")
+                        raise SegmentError(f"Error processing segment {hls_part}: {e}")
 
             # Write only successful segments to the output file
             with open(path, 'wb') as file:
@@ -573,12 +631,14 @@ class BaseCore:
 
                 return True
 
-        except httpx.RequestError as e:
-            self.logger.error(f"Request failed for URL {url}: {e}")
-            return False
-        except Exception as e:
-            self.logger.error(f"Unexpected error during download: {e}")
-            return False
+        except httpx.StreamClosed:
+            self.logger.error(f"Stream for: {url} was closed. This should not happen...")
+            raise NetworkingError(f"Stream for: {url} was closed, if this happens again, please report it!")
+
+        except Exception:
+            error = traceback.format_exc()
+            self.logger.error(f"Unknown (network) error for: {url}. Please report this! -->: {error}")
+            raise NetworkingError(f"Unknown error for: {url}. Please report this! -->: {error}")
 
     @classmethod
     def return_path(cls, video, args) -> str:

eaf_base_api-2.3.2/base_api/modules/errors.py

@@ -0,0 +1,44 @@
+# This file contains all custom exceptions for base api. They should be handled by each API individually.
+
+class KillSwitch(Exception):
+    """
+    Raised when a kill switch is triggered due to an IP Leak.
+    """
+    def __init__(self, message):
+        self.message = message
+
+
+
+class InvalidProxy(Exception):
+    """
+    Raised when a proxy set by the user is invalid. A basic scheme with regular expressions will check for possible
+    proxy configurations such as http, https and socks5 and if the entered proxy follows the certain scheme.
+    If it doesn't this exception will be raised.
+    """
+    def __init__(self, message):
+        self.message = message
+
+
+class UnknownError(Exception):
+    """
+    Raised when an unknown error occurs that I don't know about yet.
+    """
+    def __init__(self, message):
+        self.message = message
+
+
+class SegmentError(Exception):
+    """
+    Raises when a segment fails to get processed. I never that happen, but you never know.
+    """
+    def __init__(self, message):
+        self.message = message
+
+
+class NetworkingError(Exception):
+    """
+    Raises for all general network errors that are usually the fault of the user's internet connection.
+    """
+    def __init__(self, message):
+        self.message = message
+

{eaf_base_api-2.2.9 → eaf_base_api-2.3.2/eaf_base_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.2.9
+Version: 2.3.2
 Summary: A base API for EchterAlsFake's Porn APIs
 Home-page: https://github.com/EchterAlsFake/eaf_base_api
 Author: Johannes Habel

{eaf_base_api-2.2.9 → eaf_base_api-2.3.2}/eaf_base_api.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ base_api/__init__.py
 base_api/base.py
 base_api/modules/__init__.py
 base_api/modules/config.py
+base_api/modules/errors.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.9 → eaf_base_api-2.3.2}/setup.py

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