eaf-base-api 2.3.7__tar.gz → 2.4.0__tar.gz

eaf_base_api-2.4.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

{eaf_base_api-2.3.7/eaf_base_api.egg-info → eaf_base_api-2.4.0}/PKG-INFO

@@ -1,32 +1,22 @@
 Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.3.7
+Version: 2.4.0
 Summary: A base API for EchterAlsFake's Porn APIs
-Home-page: https://github.com/EchterAlsFake/eaf_base_api
-Author: Johannes Habel
-Author-email: EchterAlsFake@proton.me
+Author-email: Johannes Habel <EchterAlsFake@proton.me>
 License: LGPLv3
+Project-URL: Homepage, https://github.com/EchterAlsFake/eaf_base_api
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
 Classifier: Programming Language :: Python
+Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: m3u8
 Requires-Dist: httpx
-Provides-Extra: remux
-Requires-Dist: av; extra == "remux"
+Provides-Extra: av
+Requires-Dist: av; extra == "av"
 Provides-Extra: ffmpeg
 Requires-Dist: ffmpeg-progress-yield; extra == "ffmpeg"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: summary
 
 # EAF Base API
 

{eaf_base_api-2.3.7 → eaf_base_api-2.4.0}/base_api/base.py

@@ -4,6 +4,7 @@ import sys
 import time
 import m3u8
 import httpx
+import random
 import logging
 import traceback
 import threading
@@ -23,11 +24,110 @@ except (ModuleNotFoundError, ImportError):
     from .modules.config import config
     from .modules.progress_bars import Callback
 
+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."
+        ]
+
 loggers = {}
 
 # Default formatter
 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
+_CF_BODY_MARKERS = (
+    "cf-browser-verification",
+    "cf_chl_",  # legacy CF challenge tokens
+    "challenges.cloudflare.com",  # Turnstile/challenge host
+    "cf-turnstile",  # Turnstile widget
+    "ddos protection by",
+    "just a moment...",
+    "please enable javascript and cookies",
+    "attention required!",
+)
+# Other common WAF/CDN markers
+_OTHER_BODY_MARKERS = (
+    "akamai bot manager",
+    "bm_sz=", "abck=", "ak_bmsc", "ak_bm",                # Akamai cookies
+    "request unsuccessful. incapsula incident id",        # Imperva/Incapsula
+)
+
+def _is_text_html(resp) -> bool:
+    ct = resp.headers.get("content-type", "").lower()
+    return "text/html" in ct or ct == ""  # some sites omit CT but send HTML
+
+def _header_has_any(hdr_val: str, *needles: str) -> bool:
+    s = (hdr_val or "").lower()
+    return any(n in s for n in needles)
+
+def _body_has_any(body: str, markers: tuple) -> bool:
+    b = (body or "").lower()
+    return any(m in b for m in markers)
+
+def _looks_like_challenge(resp) -> str | None:
+    """
+    Return a human-readable reason if the response looks like a bot/WAF challenge.
+    Return None if it looks like a normal page.
+    """
+    status = resp.status_code
+    server = resp.headers.get("server", "")
+    set_cookie = resp.headers.get("set-cookie", "")
+
+    # Collect cheap, header-based indicators first
+    has_cf_cookie = _header_has_any(set_cookie, "__cf_bm", "cf_clearance", "__cf_chl")
+    served_by_cf = _header_has_any(server, "cloudflare")
+    served_by_akamai = _header_has_any(server, "akamai")
+    served_by_incapsula = _header_has_any(server, "incapsula")
+
+    # History-based indicators (redirect to /cdn-cgi/ etc.)
+    history_urls = []
+    try:
+        for h in getattr(resp, "history", []) or []:
+            history_urls.append(str(getattr(h, "url", "")))
+    except Exception:
+        pass
+    redirected_via_cdn_cgi = any("/cdn-cgi/" in u for u in history_urls)
+
+    # Read a *small* slice of the body only if it’s HTML-like
+    body_snippet = ""
+    if _is_text_html(resp):
+        try:
+            # Read up to 20KB to capture challenge markup without huge memory hit
+            text = resp.text
+            body_snippet = text[:20000]
+        except Exception:
+            body_snippet = ""
+
+    has_cf_body_markers = _body_has_any(body_snippet, _CF_BODY_MARKERS)
+    has_other_waf_markers = _body_has_any(body_snippet, _OTHER_BODY_MARKERS)
+
+    # Heuristics:
+    # 1) Hard failure statuses usually mean a challenge/waf
+    if status in (403, 429, 503):
+        if served_by_cf or has_cf_cookie or redirected_via_cdn_cgi or has_cf_body_markers or has_other_waf_markers:
+            return (f"HTTP {status} with WAF indicators "
+                    f"(server={server!r}, cf_cookie={has_cf_cookie}, "
+                    f"cdn_cgi_redirect={redirected_via_cdn_cgi}, body_markers={has_cf_body_markers or has_other_waf_markers})")
+
+    # 2) Status 200 but body is a *challenge/interstitial*
+    #    Require strong evidence in the body or cookies, not just 'Server: cloudflare'.
+    if status == 200:
+        if has_cf_cookie or redirected_via_cdn_cgi or has_cf_body_markers or has_other_waf_markers:
+            return (f"200 OK but challenge content detected "
+                    f"(server={server!r}, cf_cookie={has_cf_cookie}, "
+                    f"cdn_cgi_redirect={redirected_via_cdn_cgi}, body_markers={has_cf_body_markers or has_other_waf_markers})")
+
+    # 3) Generic: if served by a known WAF/CDN and body is *obviously* an interstitial
+    if served_by_cf and has_cf_body_markers:
+        return "Cloudflare challenge markers present in body"
+    if served_by_akamai and has_other_waf_markers:
+        return "Akamai Bot Manager markers present in body"
+    if served_by_incapsula and has_other_waf_markers:
+        return "Imperva/Incapsula challenge markers present in body"
+
+    return None
 
 def is_android():
     """Detects if the script is running on an Android device."""
@@ -168,7 +268,7 @@ class BaseCore:
     """
     The base class which has all necessary functions for other API packages
     """
-    def __init__(self, config=config, auto_init: bool = True):
+    def __init__(self, config=config, auto_init: bool = True, headers: dict = None):
         self.last_request_time = time.time()
         self.total_requests = 0 # Tracks how many requests have been made
         self.session = None
@@ -177,7 +277,7 @@ class BaseCore:
         self.cache = Cache(self.config)
         self.logger = setup_logger("BASE API - [BaseCore]", log_file=False, level=logging.ERROR)
         if auto_init:
-            self.initialize_session()
+            self.initialize_session(headers)
 
     def enable_logging(self, log_file=None, level=logging.DEBUG, log_ip=None, log_port=None):
         """
@@ -186,11 +286,6 @@ class BaseCore:
         self.logger = setup_logger(name="BASE API - [BaseCore]", log_file=log_file, level=level, http_ip=log_ip, http_port=log_port)
         self.cache.logger = setup_logger(name="BASE API - [Cache]", log_file=log_file, level=level, http_ip=log_ip, http_port=log_port)
 
-    def update_user_agent(self):
-        """Updates the User-Agent"""
-        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)
@@ -233,15 +328,22 @@ class BaseCore:
             raise KillSwitch("CRITICAL PROXY ERROR, CHECK LOGS!")
 
 
-    def initialize_session(self, verify=True): # Disable SSL verification only if you really need it....
+    def initialize_session(self, headers: dict = None, cookies: dict = None): # 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
+            verify=self.config.verify_ssl
         )
 
+        self.session.headers.update({"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36"})
+
+        if headers:
+            self.session.headers.update(headers)
+
+        if cookies:
+            self.session.cookies.update(cookies)
+
     def update_headers(self, headers: dict):
         self.session.headers.update(headers)
 
@@ -275,6 +377,7 @@ class BaseCore:
         support for proxies and custom timeout.
         """
         # Check cache first
+        last_error = None
 
         if timeout is None:
             timeout = self.config.timeout # pls don't ask thanks
@@ -289,10 +392,6 @@ class BaseCore:
                 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
-                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:
@@ -303,6 +402,23 @@ class BaseCore:
                                      follow_redirects=allow_redirects, data=data)
                 self.total_requests += 1
 
+                # NEW: bot/challenge detection
+                reason = _looks_like_challenge(response)
+                if reason:
+                    # Log a concise diagnostic with a small body preview
+                    body_preview = ""
+                    try:
+                        if _is_text_html(response):
+                            body_preview = response.text[:400]
+                    except Exception:
+                        pass
+                    self.logger.error(
+                        "Bot protection detected for %s: %s | Body[:400]=%r",
+                        url, reason, body_preview
+                    )
+                    if config.raise_bot_protection:
+                        raise BotProtectionDetected(f"{reason} at {url}")
+
                 # Log and handle non-200 status codes
                 if response.status_code != 200:
                     self.logger.warning(
@@ -312,10 +428,22 @@ class BaseCore:
                         self.logger.error(f"URL: {url} Resource not found (404). This may indicate the content is unavailable.")
                         return response  # Return None for unavailable resources
 
+                    if response.status_code == 403:
+                        time.sleep(2) # Somehow fixes 403 on missav idk man
+                        self.session.headers.update({
+                            "User-Agent": random.choice(user_agents)
+                        })
+
+                        self.logger.warning(f"Switched User agent to: {self.session.headers['User-Agent']}")
+
+
                     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 == 410:
+                        raise ResourceGone(f"Resource: {url} is Gone.")
+
                     self.logger.info(f"Retrying ({attempt}/{self.config.max_retries}) for URL: {url}")
                     continue  # Retry for other non-200 status codes
 
@@ -369,8 +497,12 @@ class BaseCore:
                 self.logger.error(f"Attempt {attempt}: The connection has been unexpectedly closed by: {url}. Retrying...")
                 continue
 
-            except httpx.RequestError as e:
+            except (httpx.RequestError, httpx.ConnectError) as e:
                 self.logger.error(f"Attempt {attempt}: Request error for URL {url}: {e}")
+
+                if "CERTIFICATE_VERIFY_FAILED" in str(e):
+                    raise ProxySSLError("Proxy has an invalid SSL certificate, to get around this error, set 'verify = False' in config")
+
                 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)
 
@@ -388,11 +520,14 @@ class BaseCore:
                 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:
+            except Exception as e:
+                last_error = e
                 self.logger.error(f"Attempt {attempt}: Unexpected error for URL {url}: {traceback.format_exc()}")
                 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.")
+        if last_error:
+            raise last_error
         return None  # Return None if all attempts fail
 
     @classmethod
@@ -594,30 +729,91 @@ class BaseCore:
     def _convert_ts_to_mp4(self, input_path: str, output_path: str, callback=None):
         try:
             import av
+            from av.audio.resampler import AudioResampler
         except (ModuleNotFoundError, ImportError):
-            raise ModuleNotFoundError("PyAV is required for remuxing. Install with `pip install av`. Not supported on Termux!")
+            raise ModuleNotFoundError("PyAV is required for remuxing. Install with pip install av. Not supported on Termux!")
 
         input_ = av.open(input_path)
-        output = av.open(output_path, "w")
+        output = av.open(output_path, mode="w", format="mp4", options={"movflags": "faststart"})
+
+        # --- VIDEO: keep your exact remux approach ---
+        in_video = input_.streams.video[0]
+        out_video = output.add_stream_from_template(template=in_video)
+
+        # --- AUDIO: copy if MP4-compatible; else transcode to AAC ---
+        in_audio = next((s for s in input_.streams if s.type == "audio"), None)
+        out_audio = None
+        transcode_audio = False
+        resampler = None
+
+        if in_audio:
+            # Common MP4-safe audio codecs to copy without transcoding.
+            copy_ok = {"aac", "alac", "mp3"}
+            codec_name = (in_audio.codec_context.name or "").lower()
+
+            if codec_name in copy_ok:
+                out_audio = output.add_stream_from_template(template=in_audio)
+            else:
+                # Build an AAC encoder stream. Match input rate/layout where possible.
+                transcode_audio = True
+                sample_rate = in_audio.codec_context.sample_rate or 48000
+                layout = (
+                    in_audio.codec_context.layout.name
+                    if getattr(in_audio.codec_context, "layout", None)
+                    else "stereo"
+                )
+                out_audio = output.add_stream("aac", rate=sample_rate)
+                # Setting layout/channels helps encoder pick sensible defaults.
+                try:
+                    out_audio.layout = layout
+                except Exception:
+                    pass
 
-        in_stream = input_.streams.video[0]
-        out_stream = output.add_stream_from_template(template=in_stream)
+                # Ensure frames handed to the AAC encoder are in a compatible sample format.
+                # ('fltp' is the usual format for AAC encoders.)
+                resampler = AudioResampler(format="fltp", layout=layout, rate=sample_rate)
 
-        packets = list(input_.demux(in_stream))
+            # --- DEMUX both streams so audio is included ---
+        demux_streams = [in_video] + ([in_audio] if in_audio else [])
+        packets = list(input_.demux(demux_streams))  # keeps your progress logic
         total = len(packets)
 
         for idx, packet in enumerate(packets):
             if packet.dts is None:
+                if callback:
+                    callback(idx + 1, total)
                 continue
-            packet.stream = out_stream
-            output.mux(packet)
+
+            if packet.stream == in_video:
+                # Your original video remux path (no explicit rescale).
+                packet.stream = out_video
+                output.mux(packet)
+
+            elif in_audio and packet.stream == in_audio:
+                if not transcode_audio:
+                    # Audio is already MP4-compatible; just remux.
+                    packet.stream = out_audio
+                    output.mux(packet)
+                else:
+                    # Decode -> (optionally resample) -> encode AAC -> mux.
+                    for frame in packet.decode():
+                        # Resample to match encoder expectations.
+                        frames = resampler.resample(frame) if resampler else [frame]
+                        for f in frames:
+                            for enc_pkt in out_audio.encode(f):
+                                output.mux(enc_pkt)
+
             if callback:
                 callback(idx + 1, total)
 
+        # Flush audio encoder if we transcoded.
+        if transcode_audio and out_audio:
+            for enc_pkt in out_audio.encode(None):
+                output.mux(enc_pkt)
+
         input_.close()
         output.close()
 
-
     def FFMPEG(self, video, quality: str, callback, path: str) -> bool:
         try:
             from ffmpeg_progress_yield import FfmpegProgress
@@ -707,9 +903,15 @@ class BaseCore:
 
         return path
 
-    @classmethod
-    def truncate(cls, string_lol) -> str:
-        return string_lol[:200]
+    def truncate(self, name: str, max_bytes: int = 245) -> str: # only 245, because we need to append .mp4
+        encoded = name.encode("utf-8")
+        if len(encoded) > max_bytes:
+            encoded = encoded[:max_bytes]
+            # Ensure not to cut in middle of a UTF-8 sequence
+            while encoded[-1] & 0b11000000 == 0b10000000:
+                encoded = encoded[:-1]
+            return encoded.decode("utf-8", errors="ignore")
+        return name
 
     @staticmethod
     def str_to_bool(value):

eaf_base_api-2.4.0/base_api/modules/config.py

@@ -0,0 +1,15 @@
+class RuntimeConfig:
+    def __init__(self):
+        self.max_cache_items = 200
+        self.max_retries = 4
+        self.request_delay = 0
+        self.timeout = 20
+        self.max_bandwidth_mb = None # Set speed limit in megabytes per second e.g, 2.0, 3.5 etc...
+        self.ffmpeg_path = "ffmpeg"
+        self.proxy = None
+        self.raise_bot_protection = False
+        self.verify_ssl = True
+        self.cookies = None
+
+# Singleton instance needed for my Porn Fetch project
+config = RuntimeConfig()

{eaf_base_api-2.3.7 → eaf_base_api-2.4.0}/base_api/modules/errors.py

@@ -42,3 +42,23 @@ class NetworkingError(Exception):
     def __init__(self, message):
         self.message = message
 
+
+class ProxySSLError(Exception):
+    """
+    Raises if a proxy request fails due to self-signed certificates or invalid TLS verification
+    """
+    def __init__(self, message):
+        self.message = message
+
+
+class ResourceGone(Exception):
+    """
+    Raises if a resource is gone (http 410 error)
+    """
+    def __init__(self, message):
+        self.message = message
+
+
+class BotProtectionDetected(Exception):
+    """Raised when Cloudflare or similar bot protection is detected."""
+    pass

{eaf_base_api-2.3.7 → eaf_base_api-2.4.0/eaf_base_api.egg-info}/PKG-INFO

@@ -1,32 +1,22 @@
 Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.3.7
+Version: 2.4.0
 Summary: A base API for EchterAlsFake's Porn APIs
-Home-page: https://github.com/EchterAlsFake/eaf_base_api
-Author: Johannes Habel
-Author-email: EchterAlsFake@proton.me
+Author-email: Johannes Habel <EchterAlsFake@proton.me>
 License: LGPLv3
+Project-URL: Homepage, https://github.com/EchterAlsFake/eaf_base_api
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
 Classifier: Programming Language :: Python
+Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: m3u8
 Requires-Dist: httpx
-Provides-Extra: remux
-Requires-Dist: av; extra == "remux"
+Provides-Extra: av
+Requires-Dist: av; extra == "av"
 Provides-Extra: ffmpeg
 Requires-Dist: ffmpeg-progress-yield; extra == "ffmpeg"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: summary
 
 # EAF Base API
 

{eaf_base_api-2.3.7 → eaf_base_api-2.4.0}/eaf_base_api.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
+MANIFEST.in
 README.md
-setup.py
+pyproject.toml
 base_api/__init__.py
 base_api/base.py
 base_api/modules/__init__.py

{eaf_base_api-2.3.7 → eaf_base_api-2.4.0}/eaf_base_api.egg-info/requires.txt

@@ -1,8 +1,8 @@
 m3u8
 httpx
 
+[av]
+av
+
 [ffmpeg]
 ffmpeg-progress-yield
-
-[remux]
-av

{eaf_base_api-2.3.7 → eaf_base_api-2.4.0}/eaf_base_api.egg-info/top_level.txt

@@ -1 +1,2 @@
 base_api
+dist

eaf_base_api-2.4.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eaf_base_api"
+version = "2.4.0"
+description = "A base API for EchterAlsFake's Porn APIs"
+readme = "README.md"
+requires-python = ">=3.6"
+license = { text = "LGPLv3" }
+authors = [
+    { name = "Johannes Habel", email = "EchterAlsFake@proton.me" }
+]
+dependencies = [
+    "m3u8",
+    "httpx",
+]
+optional-dependencies = {av = ["av"], ffmpeg = ["ffmpeg-progress-yield"]}
+classifiers = [
+    "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+    "Programming Language :: Python",
+]
+
+[project.urls]
+Homepage = "https://github.com/EchterAlsFake/eaf_base_api"
+
+[tool.setuptools]
+packages = { find = {} }

eaf_base_api-2.3.7/base_api/modules/config.py

@@ -1,37 +0,0 @@
-import random
-
-class RuntimeConfig:
-    def __init__(self):
-        self.max_cache_items = 200
-        self.max_retries = 4
-        self.request_delay = 0
-        self.timeout = 20
-        self.max_bandwidth_mb = None # Set speed limit in megabytes per second e.g, 2.0, 3.5 etc...
-        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.3.7/setup.py

@@ -1,29 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="eaf_base_api",
-    version="2.3.7",
-    packages=find_packages(),
-    install_requires=["m3u8", "httpx"],
-    extras_require={
-        "remux": ["av"],
-        "ffmpeg": ["ffmpeg-progress-yield"],
-    },
-    entry_points={
-        'console_scripts': [
-            # If you want to create any executable scripts
-        ],
-    },
-    author="Johannes Habel",
-    author_email="EchterAlsFake@proton.me",
-    description="A base API for EchterAlsFake's Porn APIs",
-    long_description=open('README.md').read(),
-    long_description_content_type='text/markdown',
-    license="LGPLv3",
-    url="https://github.com/EchterAlsFake/eaf_base_api",
-    classifiers=[
-        # Classifiers help users find your project on PyPI
-        "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
-        "Programming Language :: Python",
-    ],
-)