pkg-anime-1 1.2.2__tar.gz

pkg_anime_1-1.2.2/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: pkg-anime-1
+Version: 1.2.2
+Summary: Terminal anime downloader with live search, quality/audio selection, threaded downloading, and resume
+Requires-Dist: curl_cffi
+Requires-Dist: beautifulsoup4
+Requires-Dist: rich
+Requires-Dist: InquirerPy
+Requires-Dist: DrissionPage
+Requires-Dist: pycryptodome
+Requires-Dist: tqdm
+Dynamic: requires-dist
+Dynamic: summary

pkg_anime_1-1.2.2/anime_pahe/api.py

@@ -0,0 +1,261 @@
+import os
+import sys
+import time
+import json
+import math
+import platform
+from curl_cffi import requests
+from bs4 import BeautifulSoup
+from rich.console import Console
+
+console = Console()
+
+
+def _is_termux():
+    """Detect if running inside Termux (Android)."""
+    return (
+        os.environ.get("TERMUX_VERSION") is not None
+        or os.path.exists("/data/data/com.termux")
+        or "com.termux" in os.environ.get("PREFIX", "")
+    )
+
+
+class AnimePaheAPI:
+    def __init__(self, base_url="https://animepahe.pw"):
+        self.base_url = base_url
+        self.api_url = f"{self.base_url}/api"
+        self.session = requests.Session(impersonate="chrome120")
+        self.config_path = os.path.expanduser("~/.anime_config.json")
+        self._load_config()
+
+    def _load_config(self):
+        if os.path.exists(self.config_path):
+            with open(self.config_path, "r") as f:
+                data = json.load(f)
+                cf_clearance = data.get("cf", "")
+                user_agent = data.get("ua", "")
+
+                if cf_clearance:
+                    self.session.cookies.set(
+                        "cf_clearance", cf_clearance, domain=".animepahe.pw"
+                    )
+                if user_agent:
+                    self.session.headers.update({"User-Agent": user_agent})
+                return True
+        else:
+            self.session.headers.update(
+                {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                }
+            )
+            return False
+
+    # ─────────────────────────────────────────────
+    #  Cloudflare bypass — auto or manual
+    # ─────────────────────────────────────────────
+
+    def _auto_bypass(self):
+        console.print("\n[bold yellow][!] Cloudflare block detected.[/bold yellow]")
+
+        if _is_termux():
+            return self._manual_bypass_termux()
+
+        console.print("[cyan][*] Auto-launching browser to get clearance...[/cyan]")
+        return self._browser_bypass()
+
+    def _manual_bypass_termux(self):
+        """Manual cookie entry for Termux / Android (no GUI available)."""
+        console.print(
+            "\n[bold yellow]Termux detected — Chrome GUI cannot open automatically.[/bold yellow]\n"
+            "[cyan]Do this once on your phone:[/cyan]\n"
+            "  1. Open [bold]Chrome[/bold] on your Android device\n"
+            f"  2. Visit [link]{self.base_url}[/link] and pass the Cloudflare check\n"
+            "  3. Open Chrome DevTools (Menu → Desktop site, or use [bold]chrome://inspect[/bold] from PC)\n"
+            "     OR: install the [bold]Cookie-Editor[/bold] extension via Kiwi Browser\n"
+            "  4. Copy the value of the [bold]cf_clearance[/bold] cookie\n"
+        )
+
+        cf_val = input("  Paste cf_clearance cookie value: ").strip()
+        if not cf_val:
+            console.print("[bold red]No cookie entered. Aborting.[/bold red]")
+            return False
+
+        ua = input(
+            "  Paste your browser User-Agent (leave blank for default): "
+        ).strip()
+        if not ua:
+            ua = (
+                "Mozilla/5.0 (Linux; Android 14) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"
+            )
+
+        new_config = {"ua": ua, "cf": cf_val}
+        with open(self.config_path, "w") as f:
+            json.dump(new_config, f, indent=2)
+
+        self.session.cookies.set("cf_clearance", cf_val, domain=".animepahe.pw")
+        self.session.headers.update({"User-Agent": ua})
+
+        console.print(
+            "[bold green]✓ Cookie saved. Resuming...[/bold green]\n"
+            "[dim](Cookie will be reused automatically on next run)[/dim]\n"
+        )
+        return True
+
+    def _browser_bypass(self):
+        """Launch a headless Chrome via DrissionPage (WSL / Linux desktop / Windows)."""
+        try:
+            from DrissionPage import ChromiumPage, ChromiumOptions
+        except ImportError:
+            console.print("[bold red]DrissionPage not installed. Run: pip install DrissionPage[/bold red]")
+            return False
+
+        os.system("pkill -f chrome 2>/dev/null || true")
+        time.sleep(2)
+
+        co = ChromiumOptions()
+
+        # Try common Chrome paths — works on WSL, native Linux, Windows WSL
+        chrome_paths = [
+            "/usr/bin/google-chrome",
+            "/usr/bin/chromium-browser",
+            "/usr/bin/chromium",
+            "google-chrome",
+            "chromium",
+        ]
+        chrome_bin = None
+        import shutil
+        for p in chrome_paths:
+            if shutil.which(p) or os.path.exists(p):
+                chrome_bin = p
+                break
+
+        if chrome_bin:
+            co.set_paths(browser_path=chrome_bin)
+
+        co.set_argument("--no-sandbox")
+        co.set_argument("--disable-dev-shm-usage")
+        co.set_argument("--disable-gpu")
+
+        try:
+            page = ChromiumPage(co)
+            page.get(self.base_url)
+
+            console.print("[*] Waiting up to 30 seconds for clearance...")
+            for _ in range(30):
+                if (
+                    "animepahe" in page.title.lower()
+                    and "just a moment" not in page.title.lower()
+                ):
+                    break
+                time.sleep(1)
+
+            html = page.html
+            if "cf-mitigated" in html or "Just a moment" in html:
+                raise Exception("Timed out waiting for Cloudflare clearance.")
+
+            console.print(
+                "[bold green][+] SUCCESS! Clearance granted. Harvesting tokens...[/bold green]"
+            )
+
+            cookies_list = page.cookies()
+            user_agent = page.user_agent
+            cf_val = ""
+
+            for c in cookies_list:
+                name = c.get("name", "")
+                if name in ["cf_clearance", "__ddg1_"]:
+                    cf_val = c.get("value", "")
+                    break
+
+            if not cf_val:
+                raise Exception("Bypassed, but could not find cf_clearance cookie.")
+
+            new_config = {"ua": user_agent, "cf": cf_val}
+            with open(self.config_path, "w") as f:
+                json.dump(new_config, f, indent=2)
+
+            self.session.cookies.set("cf_clearance", cf_val, domain=".animepahe.pw")
+            self.session.headers.update({"User-Agent": user_agent})
+
+            console.print(
+                "[bold green]✓ Session automatically updated. Resuming task...[/bold green]\n"
+            )
+            return True
+
+        except Exception as e:
+            console.print(f"\n[bold red][!] Auto-Bypass Error:[/bold red] {e}")
+            return False
+        finally:
+            try:
+                page.quit()
+            except Exception:
+                pass
+
+    # ─────────────────────────────────────────────
+    #  API methods (unchanged)
+    # ─────────────────────────────────────────────
+
+    def get_all_anime(self):
+        response = self.session.get(f"{self.base_url}/anime")
+        if response.status_code == 403:
+            if self._auto_bypass():
+                return self.get_all_anime()
+            raise PermissionError("Cloudflare blocked the request.")
+
+        soup = BeautifulSoup(response.text, "html.parser")
+        anime_list = []
+        for a in soup.select('div.content-wrapper a[href^="/anime/"]'):
+            title = a.get("title", "").strip()
+            session = a.get("href", "").split("/")[-1]
+            if title and session:
+                anime_list.append({"title": title, "session": session})
+        return anime_list
+
+    def search(self, query):
+        params = {"m": "search", "q": query}
+        response = self.session.get(self.api_url, params=params)
+
+        if response.status_code == 403:
+            if self._auto_bypass():
+                return self.search(query)
+            raise PermissionError("Cloudflare blocked the request.")
+
+        return response.json().get("data", [])
+
+    def get_anime_metadata(self, anime_session):
+        params = {"m": "release", "id": anime_session, "sort": "episode_asc", "page": 1}
+        response = self.session.get(self.api_url, params=params)
+
+        if response.status_code == 403:
+            if self._auto_bypass():
+                return self.get_anime_metadata(anime_session)
+            raise PermissionError("Cloudflare blocked the request.")
+
+        data = response.json()
+        return data.get("total", 0)
+
+    def get_specific_episode_hash(self, anime_session, target_ep):
+        target_page = math.ceil(target_ep / 30)
+        params = {
+            "m": "release",
+            "id": anime_session,
+            "sort": "episode_asc",
+            "page": target_page,
+        }
+        response = self.session.get(self.api_url, params=params)
+
+        if response.status_code == 403:
+            if self._auto_bypass():
+                return self.get_specific_episode_hash(anime_session, target_ep)
+            raise PermissionError("Cloudflare blocked the request.")
+
+        data = response.json()
+        episodes = data.get("data", [])
+
+        for ep in episodes:
+            if int(ep["episode"]) == target_ep:
+                return ep["session"]
+
+        return None

pkg_anime_1-1.2.2/anime_pahe/cli.py

@@ -0,0 +1,258 @@
+import os
+import sys
+import argparse
+from rich.console import Console
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+
+from anime_pahe.api import AnimePaheAPI
+from anime_pahe.extractor import AnimeExtractor, DEFAULT_THREADS
+from anime_pahe.config import load_config, save_config, show_config, CONFIG_PATH
+
+console = Console()
+
+
+def _resolve_quality(streams, preferred_quality):
+    """
+    Return the best matching resolution string from available streams.
+    preferred_quality: "best" → highest available; "1080" → exact or next best.
+    """
+    resolutions = sorted(
+        {s["resolution"] for s in streams},
+        key=lambda r: int(r) if r.isdigit() else 0,
+        reverse=True,
+    )
+    if not resolutions:
+        return None
+
+    if preferred_quality == "best":
+        return resolutions[0]
+
+    # Exact match first
+    if preferred_quality in resolutions:
+        return preferred_quality
+
+    # Next-best (closest lower)
+    target = int(preferred_quality) if preferred_quality.isdigit() else 0
+    for r in resolutions:
+        if r.isdigit() and int(r) <= target:
+            return r
+
+    return resolutions[-1]  # fallback to lowest
+
+
+def main():
+    cfg = load_config()
+
+    parser = argparse.ArgumentParser(
+        description="Terminal Anime Downloader",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument("-a", "--anime", type=str, help="Directly search for an anime")
+    parser.add_argument(
+        "-q", "--quality",
+        type=str,
+        default=None,
+        help="Video quality: best / 1080 / 720 / 480 / 360 (default: from config)",
+    )
+    parser.add_argument(
+        "--audio",
+        type=str,
+        default=None,
+        choices=["jpn", "eng"],
+        help="Audio language: jpn or eng (default: from config)",
+    )
+    parser.add_argument(
+        "-t", "--threads",
+        type=int,
+        default=None,
+        help=f"Download threads (default: from config, currently {cfg['threads']})",
+    )
+    parser.add_argument(
+        "-d", "--download-dir",
+        type=str,
+        default=None,
+        help="Directory to save downloads (default: from config)",
+    )
+    parser.add_argument(
+        "--config",
+        action="store_true",
+        help="Show current config and exit",
+    )
+    parser.add_argument(
+        "--set-quality", type=str, metavar="QUALITY",
+        help="Save default quality to config (best/1080/720/480/360)",
+    )
+    parser.add_argument(
+        "--set-audio", type=str, metavar="LANG",
+        choices=["jpn", "eng"],
+        help="Save default audio language to config",
+    )
+    parser.add_argument(
+        "--set-threads", type=int, metavar="N",
+        help="Save default thread count to config",
+    )
+    parser.add_argument(
+        "--set-download-dir", type=str, metavar="PATH",
+        help="Save default download directory to config",
+    )
+    args = parser.parse_args()
+
+    # ── Config display / update ──────────────────────────────────────────
+    if args.config:
+        show_config()
+        sys.exit(0)
+
+    cfg_changed = False
+    if args.set_quality:
+        cfg["quality"] = args.set_quality
+        cfg_changed = True
+    if args.set_audio:
+        cfg["audio"] = args.set_audio
+        cfg_changed = True
+    if args.set_threads:
+        cfg["threads"] = args.set_threads
+        cfg_changed = True
+    if args.set_download_dir:
+        cfg["download_dir"] = args.set_download_dir
+        cfg_changed = True
+    if cfg_changed:
+        save_config(cfg)
+        console.print(f"[green]✓ Config saved to {CONFIG_PATH}[/green]")
+        show_config()
+        sys.exit(0)
+
+    # ── Resolve effective settings (CLI flag > config > default) ─────────
+    quality   = args.quality      or cfg.get("quality",      "best")
+    audio_pref= args.audio        or cfg.get("audio",        "jpn")
+    threads   = args.threads      or cfg.get("threads",      DEFAULT_THREADS)
+    dl_dir    = args.download_dir or cfg.get("download_dir", ".")
+
+    # ── Init ─────────────────────────────────────────────────────────────
+    try:
+        api = AnimePaheAPI(base_url=cfg.get("base_url", "https://animepahe.pw"))
+        extractor = AnimeExtractor(api.session)
+    except Exception as e:
+        console.print(f"[bold red]Initialization Error:[/bold red] {e}")
+        sys.exit(1)
+
+    # 1. Fetch Anime List
+    query = args.anime
+    if query:
+        console.print(f"\n[cyan]Searching API for '{query}'...[/cyan]")
+        results = api.search(query)
+    else:
+        console.print("\n[cyan]Fetching master anime directory for live search...[/cyan]")
+        results = api.get_all_anime()
+
+    if not results:
+        console.print("[bold yellow]No results found.[/bold yellow]")
+        sys.exit(0)
+
+    # 2. Live fuzzy search
+    anime_choices = [Choice(value=res["session"], name=res["title"]) for res in results]
+
+    session_id = inquirer.fuzzy(
+        message="Type to search anime:",
+        choices=anime_choices,
+        instruction="(Start typing to filter, Enter to select)",
+    ).execute()
+
+    if not session_id:
+        sys.exit(0)
+
+    selected_title = next(res["title"] for res in results if res["session"] == session_id)
+
+    # 3. Episode count
+    console.print(f"\n[cyan]Checking episode count for {selected_title}...[/cyan]")
+    total_eps = api.get_anime_metadata(session_id)
+
+    if total_eps == 0:
+        console.print("[bold yellow]No episodes found.[/bold yellow]")
+        sys.exit(0)
+
+    console.print(f"[green]✓ Found {total_eps} episodes available.[/green]")
+
+    # 4. Episode number input
+    typed_ep = inquirer.text(
+        message=f"Enter episode number to download (1-{total_eps}):",
+        validate=lambda text: text.isdigit() and 1 <= int(text) <= total_eps,
+        invalid_message=f"Please enter a valid episode number between 1 and {total_eps}",
+    ).execute()
+
+    if not typed_ep:
+        sys.exit(0)
+
+    # 5. Fetch episode hash
+    target_ep = int(typed_ep)
+    console.print("[cyan]Locating secure stream hash...[/cyan]")
+    ep_session = api.get_specific_episode_hash(session_id, target_ep)
+
+    if not ep_session:
+        console.print(
+            f"[bold red]Error:[/bold red] Could not locate stream hash for Episode {target_ep}."
+        )
+        sys.exit(1)
+
+    # 6. Fetch available streams
+    streams = extractor.get_all_streams(session_id, ep_session)
+
+    if not streams:
+        console.print("[bold red]Error:[/bold red] No streams found for this episode.")
+        sys.exit(1)
+
+    # 7. Resolve quality — show picker only if config says "best" or no exact match
+    chosen_res = _resolve_quality(streams, quality)
+
+    if quality == "best":
+        # Show picker so user can confirm / change
+        res_choices = sorted(
+            {s["resolution"] for s in streams},
+            key=lambda r: int(r) if r.isdigit() else 0,
+            reverse=True,
+        )
+        chosen_res = inquirer.select(
+            message=f"Select quality (config default: {quality}):",
+            choices=[Choice(value=r, name=f"{r}p") for r in res_choices],
+        ).execute()
+    else:
+        console.print(f"[green]Quality: {chosen_res}p (from {'--quality flag' if args.quality else 'config'})[/green]")
+
+    # 8. Resolve audio — show picker only if preferred not available at chosen res
+    audio_options = [s for s in streams if s["resolution"] == chosen_res]
+    avail_audios = [s["audio"] for s in audio_options]
+
+    if audio_pref in avail_audios:
+        kwik_link = next(s["url"] for s in audio_options if s["audio"] == audio_pref)
+        console.print(
+            f"[green]Audio: {audio_pref.upper()} (from {'--audio flag' if args.audio else 'config'})[/green]"
+        )
+    elif len(audio_options) > 1:
+        kwik_link = inquirer.select(
+            message=f"'{audio_pref}' not available — pick audio:",
+            choices=[Choice(value=s["url"], name=s["audio"].upper()) for s in audio_options],
+        ).execute()
+    else:
+        kwik_link = audio_options[0]["url"]
+        console.print(f"[green]Audio: {audio_options[0]['audio'].upper()} (only option)[/green]")
+
+    # 9. Build output path
+    safe_title = "".join(c if c.isalnum() or c in " _-" else "_" for c in selected_title)
+    filename = f"{safe_title}_EP{target_ep:02d}_{chosen_res}p.mp4"
+    os.makedirs(dl_dir, exist_ok=True)
+    out_path = os.path.join(dl_dir, filename)
+
+    console.print(f"[dim]Saving to: {out_path}[/dim]")
+
+    # 10. Download
+    extractor.download_episode(
+        session_id,
+        ep_session,
+        kwik_link,
+        out_filename=out_path,
+        threads=threads,
+    )
+
+
+if __name__ == "__main__":
+    main()

pkg_anime_1-1.2.2/anime_pahe/config.py

@@ -0,0 +1,47 @@
+import json
+import os
+
+from rich.console import Console
+
+console = Console()
+
+CONFIG_PATH = os.path.expanduser("~/.anime_pahe_config.json")
+
+DEFAULT_CONFIG = {
+    "base_url": "https://animepahe.pw",
+    "quality": "best",
+    "audio": "jpn",
+    "threads": 8,
+    "download_dir": ".",
+}
+
+
+def load_config():
+    if not os.path.exists(CONFIG_PATH):
+        return DEFAULT_CONFIG.copy()
+    try:
+        with open(CONFIG_PATH, "r") as f:
+            user = json.load(f)
+        cfg = DEFAULT_CONFIG.copy()
+        cfg.update({k: v for k, v in user.items() if k in DEFAULT_CONFIG})
+        return cfg
+    except Exception:
+        return DEFAULT_CONFIG.copy()
+
+
+def save_config(cfg):
+    try:
+        with open(CONFIG_PATH, "w") as f:
+            json.dump(cfg, f, indent=2)
+    except Exception as e:
+        console.print(f"[yellow]Warning: could not save config: {e}[/yellow]")
+
+
+def show_config():
+    cfg = load_config()
+    console.print("\n[bold cyan]Current config[/bold cyan] ([dim]~/.anime_pahe_config.json[/dim])")
+    console.print(f"  quality     : [green]{cfg['quality']}[/green]  (best / 1080 / 720 / 480 / 360)")
+    console.print(f"  audio       : [green]{cfg['audio']}[/green]   (jpn / eng)")
+    console.print(f"  threads     : [green]{cfg['threads']}[/green]")
+    console.print(f"  download_dir: [green]{cfg['download_dir']}[/green]")
+    console.print(f"  base_url    : [green]{cfg['base_url']}[/green]\n")

pkg_anime_1-1.2.2/anime_pahe/extractor.py

@@ -0,0 +1,391 @@
+import os
+import re
+import shutil
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from urllib.parse import urlparse
+
+from bs4 import BeautifulSoup
+from Crypto.Cipher import AES
+from rich.console import Console
+from tqdm import tqdm
+
+console = Console()
+
+DEFAULT_THREADS = 8
+
+
+class AnimeExtractor:
+    def __init__(self, session):
+        self.session = session
+        self.base_url = "https://animepahe.pw"
+        self.referer = "https://kwik.cx/"
+
+    # ─────────────────────────────────────────────
+    #  Step 1: get ALL quality/audio options
+    # ─────────────────────────────────────────────
+
+    def get_all_streams(self, anime_session, episode_session):
+        """Return list of dicts: [{resolution, audio, url}, ...] sorted best-first."""
+        console.print("[cyan]Fetching available streams...[/cyan]")
+        url = f"{self.base_url}/play/{anime_session}/{episode_session}"
+        response = self.session.get(url)
+
+        soup = BeautifulSoup(response.text, "html.parser")
+        streams = []
+        for btn in soup.find_all("button", attrs={"data-src": True}):
+            src = btn.get("data-src", "")
+            if "kwik" not in src:
+                continue
+            res = btn.get("data-resolution", "?")
+            audio = btn.get("data-audio", "jpn")
+            streams.append({"resolution": res, "audio": audio, "url": src})
+
+        def _res_key(s):
+            try:
+                return int(s["resolution"])
+            except (ValueError, TypeError):
+                return 0
+
+        streams.sort(key=_res_key, reverse=True)
+        return streams
+
+    # ─────────────────────────────────────────────
+    #  Step 2: unpack JS → m3u8
+    # ─────────────────────────────────────────────
+
+    def _unpack_javascript(self, args_string):
+        match = re.search(
+            r"^(.*?)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(['\"])(.*?)\4\.split\('\|'\)",
+            args_string,
+            re.DOTALL,
+        )
+        if not match:
+            console.print(
+                f"\n[bold red]=== DEBUG: RAW ARGS ===[/bold red]\n{args_string[:500]}...\n"
+            )
+            raise Exception("Could not parse the packed variables.")
+
+        p_quoted = match.group(1).strip()
+        if (p_quoted.startswith("'") and p_quoted.endswith("'")) or (
+            p_quoted.startswith('"') and p_quoted.endswith('"')
+        ):
+            p = p_quoted[1:-1]
+        else:
+            p = p_quoted
+        p = p.replace("\\'", "'").replace('\\"', '"').replace("\\\\", "\\")
+
+        a = int(match.group(2))
+        c = int(match.group(3))
+        k = match.group(5).split("|")
+
+        def e(c_val):
+            part1 = "" if c_val < a else e(c_val // a)
+            c_mod = c_val % a
+            part2 = (
+                chr(c_mod + 29)
+                if c_mod > 35
+                else "0123456789abcdefghijklmnopqrstuvwxyz"[c_mod]
+            )
+            return part1 + part2
+
+        unpacked = p
+        for i in range(c - 1, -1, -1):
+            if k[i]:
+                word = e(i)
+                unpacked = re.sub(r"\b" + word + r"\b", k[i], unpacked)
+        return unpacked
+
+    def get_m3u8(self, kwik_link):
+        console.print("[cyan]Bypassing host encryption...[/cyan]")
+        headers = {
+            "Referer": f"{self.base_url}/",
+            "User-Agent": self.session.headers.get("User-Agent", ""),
+        }
+        response = self.session.get(kwik_link, headers=headers)
+
+        if response.status_code == 403:
+            raise Exception("Kwik.cx threw a 403 Forbidden. IP might be flagged.")
+
+        script_matches = re.findall(
+            r"eval\(function\(p,a,c,k,e.*?return\s+p\}\(\s*(.*?\.split\('\|'\).*?)\)\)",
+            response.text,
+            re.DOTALL,
+        )
+        if not script_matches:
+            console.print(
+                f"\n[bold yellow]=== DEBUG: PAGE HTML ===[/bold yellow]\n{response.text[:1000]}\n"
+            )
+            raise Exception("Could not find packed video script signature.")
+
+        args_string = script_matches[-1]
+        try:
+            unpacked_js = self._unpack_javascript(args_string)
+        except Exception as e:
+            raise Exception(f"Failed to unpack Javascript natively: {e}")
+
+        m3u8_match = re.search(r"source='([^']+)'", unpacked_js)
+        if not m3u8_match:
+            console.print(
+                f"\n[bold red]=== DEBUG: UNPACKED SCRIPT ===[/bold red]\n{unpacked_js[:1000]}\n"
+            )
+            raise Exception("Failed to extract m3u8 link from unpacked script.")
+        return m3u8_match.group(1)
+
+    # ─────────────────────────────────────────────
+    #  Step 3: parse m3u8 → segment list + AES key + duration
+    # ─────────────────────────────────────────────
+
+    def _parse_m3u8(self, m3u8_url):
+        headers = {"Referer": self.referer}
+        resp = self.session.get(m3u8_url, headers=headers)
+        if resp.status_code != 200:
+            raise Exception(f"Failed to fetch m3u8 playlist (HTTP {resp.status_code})")
+
+        key_url = None
+        segments = []
+        media_sequence = 0
+        total_duration = 0.0
+
+        for line in resp.text.splitlines():
+            line = line.strip()
+            if line.startswith("#EXT-X-MEDIA-SEQUENCE"):
+                try:
+                    media_sequence = int(line.split(":", 1)[1])
+                except ValueError:
+                    pass
+            elif line.startswith("#EXT-X-KEY"):
+                m = re.search(r'URI="([^"]+)"', line)
+                if m:
+                    key_url = m.group(1)
+            elif line.startswith("#EXTINF:"):
+                try:
+                    total_duration += float(line.split(":", 1)[1].split(",")[0])
+                except (ValueError, IndexError):
+                    pass
+            elif line and not line.startswith("#"):
+                segments.append(line)
+
+        if not key_url or not segments:
+            raise Exception("m3u8 parse failed: could not find AES key URL or segments.")
+
+        key_resp = self.session.get(key_url, headers=headers)
+        if key_resp.status_code != 200:
+            raise Exception("Failed to download AES decryption key.")
+        aes_key = key_resp.content
+
+        return aes_key, segments, media_sequence, total_duration
+
+    # ─────────────────────────────────────────────
+    #  Step 4: download + AES-decrypt a single segment
+    # ─────────────────────────────────────────────
+
+    def _download_segment(self, seg_url, aes_key, iv, out_path):
+        if os.path.exists(out_path) and os.path.getsize(out_path) > 0:
+            return os.path.getsize(out_path)
+
+        headers = {"Referer": self.referer}
+        try:
+            resp = self.session.get(seg_url, headers=headers)
+            if resp.status_code != 200:
+                return 0
+            data = resp.content
+            remainder = len(data) % 16
+            if remainder:
+                data += b"\x00" * (16 - remainder)
+            cipher = AES.new(aes_key, AES.MODE_CBC, iv)
+            decrypted = cipher.decrypt(data)
+            with open(out_path, "wb") as f:
+                f.write(decrypted)
+            return len(resp.content)
+        except Exception:
+            return 0
+
+    # ─────────────────────────────────────────────
+    #  Step 5: parallel download with auto-resume
+    # ─────────────────────────────────────────────
+
+    def _download_segments(self, aes_key, segments, media_sequence, seg_dir, threads):
+        os.makedirs(seg_dir, exist_ok=True)
+
+        seg_paths = []
+        for i, url in enumerate(segments):
+            name = os.path.basename(urlparse(url).path) or f"seg_{i:05d}.ts"
+            seg_paths.append((url, os.path.join(seg_dir, name), i))
+
+        pending = [
+            (url, path, idx)
+            for url, path, idx in seg_paths
+            if not os.path.exists(path) or os.path.getsize(path) == 0
+        ]
+
+        already_done = len(segments) - len(pending)
+        if already_done:
+            console.print(
+                f"[green]Resuming — {already_done}/{len(segments)} segments already done.[/green]"
+            )
+
+        if not pending:
+            console.print("[green]All segments already downloaded. Proceeding to merge.[/green]")
+            return [p for _, p, _ in seg_paths], True
+
+        failed = []
+        total_bytes = 0
+        start = time.time()
+
+        with tqdm(
+            total=len(pending), unit="seg", desc="Downloading", dynamic_ncols=True
+        ) as pbar:
+            with ThreadPoolExecutor(max_workers=threads) as executor:
+                future_map = {}
+                for url, path, idx in pending:
+                    seq = media_sequence + idx
+                    iv = seq.to_bytes(16, byteorder="big")
+                    f = executor.submit(self._download_segment, url, aes_key, iv, path)
+                    future_map[f] = (url, path)
+
+                for future in as_completed(future_map):
+                    url, path = future_map[future]
+                    try:
+                        n = future.result()
+                        if n > 0:
+                            total_bytes += n
+                            elapsed = time.time() - start
+                            speed = (total_bytes / 1_048_576) / elapsed if elapsed > 0 else 0
+                            pbar.set_postfix_str(f"{speed:.2f} MB/s")
+                        else:
+                            failed.append(os.path.basename(path))
+                    except Exception:
+                        failed.append(os.path.basename(path))
+                    pbar.update(1)
+
+        if failed:
+            console.print(
+                f"[bold yellow][!] {len(failed)} segment(s) failed "
+                f"({', '.join(failed[:3])}{'...' if len(failed) > 3 else ''}). "
+                "Re-run the same command to resume and retry them.[/bold yellow]"
+            )
+
+        return [p for _, p, _ in seg_paths], len(failed) == 0
+
+    # ─────────────────────────────────────────────
+    #  Step 6: ffmpeg concat → final mp4 (with progress bar)
+    # ─────────────────────────────────────────────
+
+    def _merge_segments(self, seg_paths, out_file, seg_dir, cleanup=True, total_duration=0.0):
+        list_path = os.path.join(seg_dir, "file.list")
+        present = [p for p in seg_paths if os.path.exists(p) and os.path.getsize(p) > 0]
+
+        with open(list_path, "w") as f:
+            for p in present:
+                f.write(f"file '{p}'\n")
+
+        missing = len(seg_paths) - len(present)
+        label = (
+            f"Compiling {len(present)}/{len(seg_paths)} segs (missing {missing})"
+            if missing
+            else "Compiling"
+        )
+
+        cmd = [
+            "ffmpeg", "-y",
+            "-f", "concat", "-safe", "0",
+            "-i", list_path,
+            "-c", "copy",
+            "-progress", "pipe:1",
+            "-nostats",
+            out_file,
+        ]
+
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            universal_newlines=True,
+            bufsize=1,
+        )
+
+        # Drive a tqdm bar from ffmpeg's -progress output
+        with tqdm(total=100, desc=label, unit="%", dynamic_ncols=True) as pbar:
+            last_pct = 0
+            for line in process.stdout:
+                line = line.strip()
+                # out_time_ms is microseconds in ffmpeg (confusingly named)
+                if line.startswith("out_time_ms=") and total_duration > 0:
+                    try:
+                        us = int(line.split("=", 1)[1])
+                        pct = min(int(us / (total_duration * 1_000_000) * 100), 100)
+                        if pct > last_pct:
+                            pbar.update(pct - last_pct)
+                            last_pct = pct
+                    except (ValueError, ZeroDivisionError):
+                        pass
+                elif line == "progress=end":
+                    if last_pct < 100:
+                        pbar.update(100 - last_pct)
+                        last_pct = 100
+
+            process.wait()
+            # Ensure bar reaches 100% even if progress output was incomplete
+            if last_pct < 100:
+                pbar.update(100 - last_pct)
+
+        if process.returncode != 0:
+            raise subprocess.CalledProcessError(process.returncode, cmd)
+
+        if cleanup:
+            shutil.rmtree(seg_dir, ignore_errors=True)
+
+    # ─────────────────────────────────────────────
+    #  Public entry point
+    # ─────────────────────────────────────────────
+
+    def download_episode(
+        self,
+        anime_session,
+        episode_session,
+        kwik_link,
+        out_filename=None,
+        threads=DEFAULT_THREADS,
+    ):
+        try:
+            m3u8_url = self.get_m3u8(kwik_link)
+            console.print("\n[bold green]✓ Video stream secured![/bold green]")
+
+            aes_key, segments, media_sequence, total_duration = self._parse_m3u8(m3u8_url)
+            console.print(
+                f"[cyan]{len(segments)} segments found. "
+                f"Downloading with {threads} threads...[/cyan]\n"
+            )
+
+            if not out_filename:
+                out_filename = f"Episode_{episode_session[:8]}.mp4"
+
+            seg_dir = os.path.join(
+                os.path.dirname(os.path.abspath(out_filename)),
+                f".segments_{episode_session[:8]}",
+            )
+
+            seg_paths, success = self._download_segments(
+                aes_key, segments, media_sequence, seg_dir, threads
+            )
+
+            # Always compile — keep temp dir only when retry is needed
+            self._merge_segments(
+                seg_paths, out_filename, seg_dir,
+                cleanup=success,
+                total_duration=total_duration,
+            )
+
+            if success:
+                console.print(f"\n[bold green]✓ Done: {out_filename}[/bold green]")
+            else:
+                console.print(
+                    f"\n[bold yellow]✓ Partial video saved: {out_filename}[/bold yellow]\n"
+                    "[yellow]Re-run the same command to download missing segments "
+                    "and get a clean version.[/yellow]"
+                )
+
+        except Exception as e:
+            console.print(f"\n[bold red][!] Extraction Failed:[/bold red] {e}")

pkg_anime_1-1.2.2/pkg_anime_1.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: pkg-anime-1
+Version: 1.2.2
+Summary: Terminal anime downloader with live search, quality/audio selection, threaded downloading, and resume
+Requires-Dist: curl_cffi
+Requires-Dist: beautifulsoup4
+Requires-Dist: rich
+Requires-Dist: InquirerPy
+Requires-Dist: DrissionPage
+Requires-Dist: pycryptodome
+Requires-Dist: tqdm
+Dynamic: requires-dist
+Dynamic: summary

pkg_anime_1-1.2.2/pkg_anime_1.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+setup.py
+anime_pahe/__init__.py
+anime_pahe/api.py
+anime_pahe/cli.py
+anime_pahe/config.py
+anime_pahe/extractor.py
+pkg_anime_1.egg-info/PKG-INFO
+pkg_anime_1.egg-info/SOURCES.txt
+pkg_anime_1.egg-info/dependency_links.txt
+pkg_anime_1.egg-info/entry_points.txt
+pkg_anime_1.egg-info/requires.txt
+pkg_anime_1.egg-info/top_level.txt

pkg_anime_1-1.2.2/pkg_anime_1.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pkg_anime_1-1.2.2/pkg_anime_1.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+anime = anime_pahe.cli:main

pkg_anime_1-1.2.2/pkg_anime_1.egg-info/requires.txt

@@ -0,0 +1,7 @@
+curl_cffi
+beautifulsoup4
+rich
+InquirerPy
+DrissionPage
+pycryptodome
+tqdm

pkg_anime_1-1.2.2/pkg_anime_1.egg-info/top_level.txt

@@ -0,0 +1 @@
+anime_pahe

pkg_anime_1-1.2.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pkg_anime_1-1.2.2/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="pkg-anime-1",
+    version="1.2.2",
+    description="Terminal anime downloader with live search, quality/audio selection, threaded downloading, and resume",
+    packages=find_packages(),
+    install_requires=[
+        "curl_cffi",        # Stealth requests to bypass Kwik 403 blocks
+        "beautifulsoup4",   # Parse stream buttons and anime list
+        "rich",             # Terminal UI
+        "InquirerPy",       # Real-time fuzzy live-search + selection prompts
+        "DrissionPage",     # Auto-bypasser for Cloudflare
+        "pycryptodome",     # AES-128 segment decryption
+        "tqdm",             # Threaded download progress bar
+    ],
+    entry_points={
+        "console_scripts": [
+            "anime=anime_pahe.cli:main",
+        ],
+    },
+)