eaf-base-api 2.3.8__tar.gz → 2.4.2__tar.gz

eaf_base_api-2.4.2/MANIFEST.in

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

{eaf_base_api-2.3.8/eaf_base_api.egg-info → eaf_base_api-2.4.2}/PKG-INFO

@@ -1,32 +1,22 @@
 Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.3.8
+Version: 2.4.2
 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.8 → eaf_base_api-2.4.2}/base_api/base.py

@@ -4,11 +4,12 @@ import sys
 import time
 import m3u8
 import httpx
+import random
 import logging
 import traceback
 import threading
 
-from typing import Union
+from typing import Any, Dict, List, Optional, Union
 from functools import lru_cache
 from urllib.parse import urljoin
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -23,11 +24,215 @@ 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 = {}
+HEIGHT_FROM_URI = re.compile(r'(?<!\d)(\d{3,4})[pP](?!\d)')  # e.g., 1080p, 720P
+
+def _height_from_variant(variant) -> Optional[int]:
+    """Extract height from a variant:
+    1) stream_info.resolution (w, h)
+    2) URI pattern like .../720p/...
+    """
+    if getattr(variant, "stream_info", None) and variant.stream_info.resolution:
+        _, h = variant.stream_info.resolution  # (w, h)
+        return int(h)
+
+    if variant.uri:
+        m = HEIGHT_FROM_URI.search(variant.uri)
+        if m:
+            return int(m.group(1))
+
+    return None
+
+def _is_video_playlist(variant) -> bool:
+    """Filter out I-frames/audio-only playlists."""
+    # m3u8 lib sometimes sets is_iframe if EXT-X-I-FRAME-STREAM-INF is present.
+    if getattr(variant, "is_iframe", False):
+        return False
+
+    # If codecs known and contain only audio (mp4a, ac-3, ec-3, etc.)
+    codecs = getattr(variant.stream_info, "codecs", None) if getattr(variant, "stream_info", None) else None
+    if codecs:
+        # very light heuristic: if no video codec substring, probably audio-only.
+        # video: avc1, hvc1, hev1, vp9, av01, dvh
+        if not any(v in codecs.lower() for v in ("avc1", "hvc1", "hev1", "av01", "vp9", "dvh")):
+            return False
+
+    return True
+
+def _collect_variants(master: m3u8.M3U8) -> List[Dict[str, Any]]:
+    """Normalize playlist variants to a comparable list."""
+    items: List[Dict[str, Any]] = []
+    for v in master.playlists:
+        if not _is_video_playlist(v):
+            continue
+
+        h = _height_from_variant(v)
+        bw = getattr(v.stream_info, "bandwidth", 0) if getattr(v, "stream_info", None) else 0
+        fr = getattr(v.stream_info, "frame_rate", 0.0) if getattr(v, "stream_info", None) else 0.0
+        items.append({
+            "uri": v.uri,
+            "height": h,                 # may be None
+            "bandwidth": int(bw or 0),
+            "frame_rate": float(fr or 0.0),
+            "resolution": getattr(v.stream_info, "resolution", None) if getattr(v, "stream_info", None) else None,
+            "raw": v
+        })
+    return items
+
+def _pick_by_label(variants: List[Dict[str, Any]], label: str) -> Dict[str, Any]:
+    """best / worst / half based on a combined rank by (height, bandwidth)."""
+    # rank by height first, then bandwidth as tiebreaker
+    def key_fn(v):
+        return (v["height"] or 0, v["bandwidth"])
+    ordered = sorted(variants, key=key_fn)
+
+    if not ordered:
+        raise ValueError("No video variants available in master playlist.")
+
+    if label == "worst":
+        return ordered[0]
+    elif label == "half":
+        return ordered[len(ordered)//2]
+    elif label == "best":
+        return ordered[-1]
+    else:
+        raise ValueError("Invalid quality label.")
+
+def _normalize_quality(quality: Union[str, int]) -> Union[str, int]:
+    """Convert '1080p'->1080, '720'->720, keep labels as-is."""
+    if isinstance(quality, int):
+        return quality
+    q = str(quality).strip().lower()
+    if q in {"best", "worst", "half"}:
+        return q
+    m = re.search(r'(\d{3,4})', q)
+    if m:
+        return int(m.group(1))
+    raise ValueError(f"Invalid quality value: {quality!r}")
+
+def _pick_by_height(variants: List[Dict[str, Any]], target: int) -> Dict[str, Any]:
+    """Choose the highest height ≤ target; else closest by absolute diff (ties -> higher)."""
+    with_height = [v for v in variants if v["height"] is not None]
+    if with_height:
+        # Prefer height <= target
+        below_eq = [v for v in with_height if v["height"] <= target]
+        if below_eq:
+            # Among same height, prefer higher bandwidth then higher fps
+            best = sorted(below_eq, key=lambda v: (v["height"], v["bandwidth"], v["frame_rate"]))[-1]
+            return best
+
+        # Fallback: closest by absolute diff; ties -> higher height
+        def diff_key(v):
+            return (abs(v["height"] - target), -v["height"], v["bandwidth"], v["frame_rate"])
+        return sorted(with_height, key=diff_key)[0]
+
+    # If we have no heights at all, fall back to bandwidth ranking
+    return sorted(variants, key=lambda v: v["bandwidth"])[-1]
+
+
 
 # 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."""
@@ -50,6 +255,7 @@ LOG_COLORS = {
 }
 RESET_COLOR = "\033[0m"
 
+
 class ColoredFormatter(logging.Formatter):
     def format(self, record):
         log_message = super().format(record)
@@ -168,7 +374,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 +383,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 +392,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)
@@ -204,7 +405,7 @@ class BaseCore:
         proxy_ip = self.config.proxy
         pattern = re.compile(
             r'^(?P<scheme>http|socks5)://'
-            r'(?:(?:\w+:\w+)@)?'  # optional user:pass@
+            r'(?:\w+:\w+@)?'  # optional user:pass@
             r'(?P<host>[a-zA-Z0-9.-]+)'
             r':(?P<port>\d{1,5})$'
         )
@@ -233,15 +434,22 @@ class BaseCore:
             raise KillSwitch("CRITICAL PROXY ERROR, CHECK LOGS!")
 
 
-    def initialize_session(self): # 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=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 +483,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 +498,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 +508,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 +534,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
 
@@ -392,11 +626,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:
+            pass
         return None  # Return None if all attempts fail
 
     @classmethod
@@ -430,67 +667,88 @@ class BaseCore:
         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"""
-        if "#" in m3u8_url:
-            playlist = m3u8.loads(m3u8_url)
-            self.logger.debug("Resolved custom m3u8")
+    def get_m3u8_by_quality(self, m3u8_url: str, quality: Union[str, int]) -> str:
+        """
+        Return the media-playlist URL for the requested quality.
 
+        quality:
+          - 'best' | 'half' | 'worst'
+          - 1080 / '1080' / '1080p' (and similar)
+        """
+        # Resolve master content
+        if m3u8_url.lstrip().startswith("#EXTM3U"):
+            master = m3u8.loads(m3u8_url)
+            self.logger.debug("Resolved inline/custom m3u8 master content.")
+            base_for_join = ""  # URIs should be absolute in inline cases; join will handle if relative
         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.")
-
-        # Extract available qualities and URLs
-        qualities = {
-            (variant.stream_info.resolution or "unknown"): variant.uri
-            for variant in playlist.playlists
-        } # Fetches the available qualities
+            content = self.fetch(url=m3u8_url)
+            master = m3u8.loads(content)
+            base_for_join = m3u8_url
+            self.logger.debug(f"Resolved m3u8 master: {m3u8_url}")
 
-        # Sort qualities by resolution (width x height)
-        sorted_qualities = sorted(
-            qualities.items(),
-            key=lambda x: (x[0][0] * x[0][1]) if x[0] != "unknown" else 0
-        ) # Sorts qualities to support different HLS naming schemes
+        if not master.is_variant:
+            raise ValueError("Provided URL/content is not a master playlist.")
 
-        # Select based on quality preference
-        if quality == "best":
-            url_tmp = sorted_qualities[-1][1]  # Highest resolution URL
+        variants = _collect_variants(master)
+        if not variants:
+            raise ValueError("No usable video variants found in master playlist.")
 
-        elif quality == "worst":
-            url_tmp = sorted_qualities[0][1]  # Lowest resolution URL
+        q = _normalize_quality(quality)
+        if isinstance(q, str):  # 'best'/'half'/'worst'
+            chosen = _pick_by_label(variants, q)
+        else:  # numeric height like 1080, 720, etc.
+            chosen = _pick_by_height(variants, q)
 
-        elif quality == "half":
-            url_tmp = sorted_qualities[len(sorted_qualities) // 2][1]  # Mid-quality URL
+        full_url = urljoin(base_for_join or m3u8_url, chosen["uri"])
+        return full_url
 
+    def list_available_qualities(self, m3u8_url: str) -> List[int]:
+        """
+        Inspect the master playlist and return sorted unique heights (e.g., [240, 360, 480, 720, 1080]).
+        """
+        if m3u8_url.lstrip().startswith("#EXTM3U"):
+            master = m3u8.loads(m3u8_url)
         else:
-            raise ValueError("Invalid quality provided.")
-
-        full_url = urljoin(m3u8_url, url_tmp) # Merges the primary with the new URL to get the full URL path
-        return full_url
+            content = self.fetch(url=m3u8_url)
+            master = m3u8.loads(content)
+
+        if not master.is_variant:
+            return []
+
+        heights = {h for h in (_height_from_variant(v) for v in master.playlists) if h is not None}
+        if heights:
+            return sorted(heights)
+        # fallback: bandwidth-only (roughly infer tiers)
+        by_bw = sorted(
+            (getattr(v.stream_info, "bandwidth", 0) for v in master.playlists if _is_video_playlist(v)),
+            key=int
+        )
+        # Return rank numbers instead of heights if we truly can't infer—kept simple:
+        return [i for i, _ in enumerate(by_bw, start=1)]
 
-    @lru_cache(maxsize=250)
-    def get_segments(self, m3u8_url_master: str, quality: str) -> list:
-        """Gets all video segments from a given quality and the primary m3u8 URL"""
+    def get_segments(self, m3u8_url_master: str, quality: Union[str, int]) -> list:
         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}")
+        self.logger.debug(f"Trying to fetch segment from m3u8 -> {m3u8_url}")
         content = self.fetch(url=m3u8_url)
 
+        segments = []
         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...")
+            self.logger.warning("Media playlist expected; got variant. Resolving to first sub-playlist...")
             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")
+        if getattr(m3u8_processed, "segment_map", None):
+            init_uri = m3u8_processed.segment_map[0].uri
+            init_url = urljoin(m3u8_url, init_uri)
+            segments.append(init_url)
+            self.logger.debug(f"Found init segment: {init_url}")
+
+        segments.extend(urljoin(m3u8_url, seg.uri) for seg in m3u8_processed.segments)
+        self.logger.debug(f"Fetched {len(segments)} segments from m3u8 URL (including init if present)")
         return segments
 
     def download_segment(self, url: str, timeout: int) -> tuple[str, bytes, bool]:
@@ -597,31 +855,92 @@ class BaseCore:
 
     def _convert_ts_to_mp4(self, input_path: str, output_path: str, callback=None):
         try:
-            import av
-        except (ModuleNotFoundError, ImportError):
-            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")
+            from av import open as av_open
+            from av.audio.resampler import AudioResampler
+        except (ModuleNotFoundError, ImportError) as e:
+            raise ModuleNotFoundError(f"PyAV is required for remuxing. Install with pip install av. Not supported on Termux! {e}")
+
+        input_ = av_open(input_path)
+        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
@@ -656,39 +975,91 @@ class BaseCore:
 
         return False
 
-    def legacy_download(self, path: str, url: str, callback=None) -> bool:
+    def legacy_download(self, path: str, url: str, callback=None,
+                        chunk_size: int = 1 << 20,  # 1 MiB
+                        max_retries: int = 5,
+                        read_timeout: float = 120.0) -> bool:
         """
-        Download a file using streaming, with support for progress updates.
+        Download a file using streaming with stall tolerance and resume.
+        Assumes self.session is an httpx.Client.
         """
         try:
-            with self.session.stream("GET", url, timeout=30) as response:  # Use a reasonable timeout
-                response.raise_for_status()
-                file_size = int(response.headers.get('content-length', 0))
+            # progress UI fallback
+            progress_bar = None
+            if callback is None:
+                progress_bar = Callback()
 
-                if callback is None:
-                    progress_bar = Callback()
+            # how many bytes we already have (for resume)
+            downloaded_so_far = os.path.getsize(path) if os.path.exists(path) else 0
+            etag = None
+            attempt = 0
 
-                downloaded_so_far = 0
+            # prefer a longer read timeout to ride out throttling pauses
+            timeout = httpx.Timeout(connect=10.0, read=read_timeout, write=30.0, pool=30.0)
 
-                # Open file for writing
-                with open(path, 'wb') as file:
-                    for chunk in response.iter_bytes(chunk_size=1024):
-                        if not chunk:
-                            break  # End of stream
-
-                        file.write(chunk)
-                        downloaded_so_far += len(chunk)
-
-                        # Update progress
-                        if callback:
-                            callback(downloaded_so_far, file_size)
-                        else:
-                            progress_bar.text_progress_bar(downloaded=downloaded_so_far, total=file_size)
-
-                if not callback:
-                    del progress_bar
-
-                return True
+            while True:
+                headers = {
+                }
+                if downloaded_so_far:
+                    headers["Range"] = f"bytes={downloaded_so_far}-"
+
+                # stream the next segment (or whole file if starting fresh)
+                with self.session.stream("GET", url, headers=headers,
+                                         follow_redirects=True, timeout=timeout) as response:
+                    # If we asked for a Range and got 200, server ignored it: start over.
+                    if downloaded_so_far and response.status_code == 200:
+                        downloaded_so_far = 0  # restart from scratch
+                    response.raise_for_status()
+
+                    # track ETag to detect mid-download content changes
+                    etag_cur = response.headers.get("ETag")
+                    if etag is None:
+                        etag = etag_cur
+                    elif etag_cur and etag_cur != etag:
+                        raise RuntimeError("Remote content changed during download")
+
+                    total = None
+                    # Prefer Content-Range total when resuming; else fall back to Content-Length
+                    cr = response.headers.get("Content-Range")  # e.g., "bytes start-end/total"
+                    if cr and "/" in cr:
+                        try:
+                            total = int(cr.rsplit("/", 1)[1])
+                        except ValueError:
+                            total = None
+                    if total is None:
+                        try:
+                            total = int(response.headers.get("Content-Length", "0")) or None
+                        except ValueError:
+                            total = None
+
+                    mode = "ab" if downloaded_so_far else "wb"
+                    with open(path, mode) as file:
+                        try:
+                            for chunk in response.iter_bytes(chunk_size=chunk_size):
+                                if not chunk:
+                                    continue
+                                file.write(chunk)
+                                downloaded_so_far += len(chunk)
+
+                                # update progress
+                                if callback:
+                                    callback(downloaded_so_far, total or 0)
+
+                                else:
+                                    progress_bar.text_progress_bar(downloaded=downloaded_so_far, total=total or 0)
+
+                            # finished successfully
+                            if progress_bar:
+                                del progress_bar
+                            return True
+
+                        except httpx.ReadTimeout:
+                            # stall: back off and retry from current offset
+                            attempt += 1
+                            if attempt > max_retries:
+                                raise
+                            time.sleep(min(2 ** attempt, 30))
+                            continue  # loop retries with Range  # let him coook!!!
 
         except httpx.StreamClosed:
             self.logger.error(f"Stream for: {url} was closed. This should not happen...")
@@ -711,9 +1082,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.2/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.8 → eaf_base_api-2.4.2}/base_api/modules/errors.py

@@ -48,4 +48,17 @@ 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
+        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.8 → eaf_base_api-2.4.2/eaf_base_api.egg-info}/PKG-INFO

@@ -1,32 +1,22 @@
 Metadata-Version: 2.4
 Name: eaf_base_api
-Version: 2.3.8
+Version: 2.4.2
 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.8 → eaf_base_api-2.4.2}/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.8 → eaf_base_api-2.4.2}/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.4.2/eaf_base_api.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+base_api
+build
+dist

eaf_base_api-2.4.2/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.2"
+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.8/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.8/eaf_base_api.egg-info/top_level.txt

@@ -1 +0,0 @@
-base_api

eaf_base_api-2.3.8/setup.py

@@ -1,29 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="eaf_base_api",
-    version="2.3.8",
-    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",
-    ],
-)