java-extention 1.1.1__py3-none-any.whl

jav_dl_tmux/__init__.py

@@ -0,0 +1,4 @@
+"""jav-dl-tmux — MissAV search + threaded HLS/MP4 downloader. armv7l / Termux safe."""
+
+__version__ = "1.1.1"
+__author__ = "Axiom"

jav_dl_tmux/__main__.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""
+jav-dl-tmux  —  MissAV search + threaded HLS/MP4 downloader.
+No browser. No cookies. No setup.  armv7l / Termux safe.
+
+Usage:
+    jav-dl-tmux                        # interactive menu
+    jav-dl-tmux "STARS-123"            # search immediately
+    jav-dl-tmux "STARS" --recent       # recent uploads
+    jav-dl-tmux "STARS-123" -r 720     # prefer 720p
+    jav-dl-tmux "STARS-123" -t 4       # 4-thread download (default, safe on 2 GB RAM)
+    jav-dl-tmux "STARS-123" -o ~/dl    # custom output dir
+"""
+from __future__ import annotations
+
+import re
+import sys
+import platform
+import argparse
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel   import Panel
+from rich.prompt  import Prompt, IntPrompt
+from rich.table   import Table
+from rich.live    import Live
+from rich         import box
+
+from .scraper    import MissAV
+from .downloader import download_video, sanitize_filename, _HAS_CFFI
+
+console      = Console()
+DOWNLOAD_DIR = Path("~/downloads").expanduser()
+
+_ARCH = platform.machine().lower()
+_RAM_CONSTRAINED = _ARCH in ("armv7l", "armv6l", "i686", "i386")
+_DEFAULT_THREADS  = 4   # safe on 2 GB RAM — raise to 8/16 on beefier machines
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Banner
+# ─────────────────────────────────────────────────────────────────
+
+def banner() -> None:
+    backend = "curl_cffi (Chrome TLS)" if _HAS_CFFI else "urllib3 (fallback)"
+    arch_note = f"  [dim]arch:[/dim] {_ARCH}" if _RAM_CONSTRAINED else ""
+    console.print(Panel.fit(
+        f"[bold red]JAV Downloader[/bold red]  [dim]v1.1.1[/dim]\n"
+        f"[dim]backend:[/dim] {backend}   "
+        f"[dim]threads:[/dim] {_DEFAULT_THREADS}{arch_note}",
+        border_style="red",
+    ))
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Listing helpers
+# ─────────────────────────────────────────────────────────────────
+
+def show_results(results, title: str = "Results"):
+    if not results:
+        console.print("[red]No results.[/red]")
+        return None
+    table = Table(
+        show_header=True, header_style="bold cyan",
+        box=box.SIMPLE_HEAVY, show_lines=False, title=title,
+    )
+    table.add_column("#",     style="dim",         width=4)
+    table.add_column("Code",  style="bold yellow",  width=14)
+    table.add_column("Title", min_width=28)
+    table.add_column("Date",  width=12, style="dim")
+    for i, v in enumerate(results, 1):
+        table.add_row(str(i), v.code or "-", (v.title or "")[:60], v.date or "-")
+    console.print(table)
+    return results
+
+
+def ask_index(n: int, prompt: str = "Select", default: int = 1) -> int:
+    return IntPrompt.ask(
+        f"[bold]{prompt}[/bold]", default=default,
+        choices=[str(i) for i in range(1, n + 1)],
+    ) - 1
+
+
+def ask_resolution(variants: list[dict]) -> dict:
+    if not variants:
+        return {}
+    table = Table(
+        show_header=True, header_style="bold magenta",
+        box=box.SIMPLE, title="Available resolutions",
+    )
+    table.add_column("#",          width=4)
+    table.add_column("Resolution", width=12)
+    table.add_column("Bandwidth",  width=14)
+    for i, v in enumerate(variants, 1):
+        bw = v.get("bandwidth", "?")
+        bw_str = f"{bw / 1_000_000:.1f} Mbps" if isinstance(bw, int) else str(bw)
+        table.add_row(str(i), v["resolution"], bw_str)
+    console.print(table)
+    idx = IntPrompt.ask(
+        "Choose resolution", default=1,
+        choices=[str(i) for i in range(1, len(variants) + 1)],
+    ) - 1
+    return variants[idx]
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Progress bar renderer
+# ─────────────────────────────────────────────────────────────────
+
+def _render_bar(state: dict) -> str:
+    d, t, s = state["done"], state["total"], state["speed"]
+    if not t:
+        pct, bar = 0, ""
+    else:
+        pct = min(100, int(d * 100 / t))
+        bar = "█" * (pct // 4) + "░" * (25 - pct // 4)
+    speed_str = (
+        f"{s / 1_000_000:.2f} MB/s" if s >= 1_000_000
+        else f"{s / 1_000:.0f} KB/s" if s >= 1_000
+        else f"{s:.0f} B/s"
+    )
+    return (
+        f"[cyan]{bar}[/cyan] {pct:3d}%   "
+        f"[dim]{d / 1_048_576:6.1f} / {t / 1_048_576:6.1f} MB   "
+        f"{speed_str}[/dim]"
+    )
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Core run
+# ─────────────────────────────────────────────────────────────────
+
+def run(args: argparse.Namespace) -> None:
+    banner()
+    api = MissAV()
+
+    # ── 1. Pick something to download ────────────────────────────
+    if args.recent:
+        results = api.recent()
+        results = show_results(results, f"Recent uploads ({len(results)})") or []
+        if not results:
+            return
+        idx      = ask_index(len(results), "Pick", 1)
+        selected = results[idx]
+
+    elif args.query:
+        console.print(f"\n[bold]Searching:[/bold] {args.query}")
+        results = api.search(args.query)
+        results = show_results(results, f"Search '{args.query}'") or []
+        if not results:
+            console.print("[red]No matches.[/red]")
+            return
+        # auto-pick when query is an exact code and only one result
+        if re.match(r'^[A-Z]{2,5}-\d{2,5}$', args.query.upper()) and len(results) == 1:
+            selected = results[0]
+            console.print(f"[green]Auto-selected:[/green] {selected.code} — {selected.title}")
+        else:
+            idx      = ask_index(len(results), "Pick", 1)
+            selected = results[idx]
+
+    else:
+        # fully interactive
+        mode = Prompt.ask("[bold]What do you want?[/bold]",
+                          choices=["search", "recent"], default="search")
+        if mode == "search":
+            q       = Prompt.ask("[bold]Search query[/bold]")
+            results = api.search(q)
+            results = show_results(results, f"Search '{q}'") or []
+        else:
+            results = api.recent()
+            results = show_results(results, "Recent uploads") or []
+        if not results:
+            return
+        idx      = ask_index(len(results), "Pick", 1)
+        selected = results[idx]
+
+    # ── 2. Fetch full video page (m3u8) ──────────────────────────
+    console.print(f"\n[dim]Fetching video page:[/dim] {selected.url}")
+    full = api.video(selected.slug)
+    m3u8 = getattr(full, "m3u8", "")
+    if not m3u8:
+        console.print(f"[red]No m3u8 stream found for {full.code}.[/red]")
+        return
+    console.print(f"[dim]Stream:[/dim] {m3u8[:72]}…" if len(m3u8) > 72 else f"[dim]Stream:[/dim] {m3u8}")
+
+    # ── 3. Resolution picker ──────────────────────────────────────
+    chosen_res = args.resolution
+    if not chosen_res:
+        variants = api.resolutions(m3u8)
+        if variants:
+            pick = ask_resolution(variants)
+            chosen_res = pick["resolution"].split("x")[-1] if "x" in pick["resolution"] else None
+            if isinstance(pick.get("bandwidth"), int):
+                console.print(
+                    f"[green]Chosen:[/green] {pick['resolution']} "
+                    f"@ {pick['bandwidth'] / 1_000_000:.1f} Mbps"
+                )
+
+    # ── 4. Download ───────────────────────────────────────────────
+    out_dir = Path(args.output).expanduser().resolve()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    state: dict = {"done": 0, "total": 1, "speed": 0.0}
+
+    with Live(_render_bar(state), refresh_per_second=8,
+              console=console, transient=True) as live:
+        def prog(d: int, t: int, s: float) -> None:
+            state.update(done=d, total=t, speed=s)
+            live.update(_render_bar(state))
+
+        try:
+            out = download_video(
+                full, out_dir,
+                threads=args.threads,
+                preferred_resolution=str(chosen_res) if chosen_res else None,
+                progress=prog,
+            )
+        except Exception as e:
+            console.print(f"[bold red]Download error:[/bold red] {e}")
+            return
+
+    sz_mb = out.stat().st_size / 1_048_576
+    console.print(Panel.fit(
+        f"[bold green]Done![/bold green]\n"
+        f"[dim]Saved:[/dim] [cyan]{out}[/cyan]\n"
+        f"[dim]Size:[/dim]  {sz_mb:.1f} MB",
+        border_style="green",
+    ))
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Entry
+# ─────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="MissAV downloader — no browser, no cookies, armv7l safe",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument("query",    nargs="?",
+                        help="Search query / JAV code (e.g. STARS-123)")
+    parser.add_argument("--recent", action="store_true",
+                        help="Show recent uploads instead of searching")
+    parser.add_argument("-r", "--resolution",
+                        help="Preferred resolution height (1080, 720, 480 …)")
+    parser.add_argument("-t", "--threads", type=int, default=_DEFAULT_THREADS,
+                        help=f"Download threads (default {_DEFAULT_THREADS}, safe on 2 GB RAM)")
+    parser.add_argument("-o", "--output", default=str(DOWNLOAD_DIR),
+                        help=f"Output directory (default {DOWNLOAD_DIR})")
+    args = parser.parse_args()
+
+    try:
+        run(args)
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Aborted.[/yellow]")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"\n[bold red]Error:[/bold red] {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

jav_dl_tmux/downloader.py

@@ -0,0 +1,477 @@
+"""
+Downloader — streaming HLS (.ts segments) + MP4 chunked.
+Tuned for armv7l / 2 GB RAM:
+  - Default 4 threads (not 16) — 4× a typical 4 MB segment = 16 MB working set
+  - Segments streamed directly to disk, never fully held in RAM
+  - Concat phase reads one file at a time in 256 KB chunks
+  - Range-request pool capped at 4 concurrent connections
+  - ffmpeg path preferred when available (zero extra RAM, fastest)
+"""
+from __future__ import annotations
+
+import os
+import re
+import time
+import shutil
+import threading
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Optional, Callable
+
+try:
+    from curl_cffi import requests as _cffi  # type: ignore
+    _HAS_CFFI = True
+except Exception:
+    _HAS_CFFI = False
+
+import urllib3
+from urllib3.util.retry import Retry
+from urllib3.util.ssl_ import create_urllib3_context
+
+UA       = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+            "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+IMPERSONATE = "chrome120"
+REFERER  = "https://missav.live/"
+
+# 256 KB stream chunks — small enough for 2 GB RAM
+_STREAM_CHUNK = 256 * 1024
+
+ProgressFn = Callable[[int, int, float], None]
+
+
+def _noop_progress(_d: int, _t: int, _s: float) -> None: ...
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Fetcher — shared across worker threads
+# ─────────────────────────────────────────────────────────────────
+
+class Fetcher:
+    """
+    Single shared session for all download workers.
+    curl_cffi when available; urllib3 with TLS 1.2+ on armv7l.
+    """
+
+    def __init__(self, max_pool: int = 8):
+        if _HAS_CFFI:
+            self.session: Optional[object] = _cffi.Session()
+            self.session.headers.update({  # type: ignore[union-attr]
+                "User-Agent": UA,
+                "Accept-Language": "en-US,en;q=0.9",
+                "Referer": REFERER,
+            })
+            self._pool: Optional[urllib3.PoolManager] = None
+        else:
+            self.session = None
+            ctx = create_urllib3_context()
+            ctx.minimum_version = 0x0303  # TLS 1.2 floor
+            self._pool = urllib3.PoolManager(
+                num_pools=max_pool,
+                maxsize=max_pool,
+                headers={"User-Agent": UA, "Referer": REFERER},
+                retries=Retry(total=5, backoff_factor=0.3,
+                              status_forcelist={429, 500, 502, 503, 504}),
+                ssl_context=ctx,
+            )
+
+    # ── text ──────────────────────────────────────────────────────
+    def text(self, url: str, timeout: float = 30.0) -> str:
+        if self.session is not None:
+            r = self.session.get(url, impersonate=IMPERSONATE, timeout=timeout)  # type: ignore
+            if r.status_code != 200:
+                raise IOError(f"HTTP {r.status_code} for {url}")
+            return r.text
+        assert self._pool is not None
+        r2 = self._pool.request("GET", url,
+                                timeout=urllib3.Timeout(connect=10, read=timeout))
+        if r2.status != 200:
+            raise IOError(f"HTTP {r2.status} for {url}")
+        return r2.data.decode("utf-8", errors="replace")
+
+    # ── bytes (full, for small payloads like sub-playlists) ───────
+    def bytes(self, url: str, timeout: float = 60.0) -> bytes:
+        if self.session is not None:
+            r = self.session.get(url, impersonate=IMPERSONATE, timeout=timeout)  # type: ignore
+            if r.status_code != 200:
+                raise IOError(f"HTTP {r.status_code} for {url}")
+            return r.content
+        assert self._pool is not None
+        r2 = self._pool.request("GET", url,
+                                timeout=urllib3.Timeout(connect=10, read=timeout),
+                                preload_content=True)
+        if r2.status != 200:
+            raise IOError(f"HTTP {r2.status} for {url}")
+        return r2.data
+
+    # ── streaming write-to-file (memory-safe for large segments) ──
+    def stream_to_file(self, url: str, dest: Path, timeout: float = 120.0) -> int:
+        """
+        Fetch url and write directly to dest in _STREAM_CHUNK chunks.
+        Returns number of bytes written.  Never holds the full payload in RAM.
+        """
+        if self.session is not None:
+            r = self.session.get(url, impersonate=IMPERSONATE,  # type: ignore
+                                 timeout=timeout, stream=True,
+                                 headers={"Referer": REFERER})
+            if r.status_code != 200:
+                raise IOError(f"HTTP {r.status_code} for {url}")
+            written = 0
+            with dest.open("wb") as fh:
+                for chunk in r.iter_content(_STREAM_CHUNK):
+                    if chunk:
+                        fh.write(chunk)
+                        written += len(chunk)
+            return written
+        else:
+            assert self._pool is not None
+            r2 = self._pool.request(
+                "GET", url,
+                headers={"Referer": REFERER},
+                timeout=urllib3.Timeout(connect=10, read=timeout),
+                preload_content=False,
+            )
+            if r2.status != 200:
+                r2.drain_conn()
+                raise IOError(f"HTTP {r2.status} for {url}")
+            written = 0
+            try:
+                with dest.open("wb") as fh:
+                    while True:
+                        chunk = r2.read(_STREAM_CHUNK)
+                        if not chunk:
+                            break
+                        fh.write(chunk)
+                        written += len(chunk)
+            finally:
+                r2.drain_conn()
+                r2.release_conn()
+            return written
+
+    # ── HEAD / content-length ──────────────────────────────────────
+    def head_size(self, url: str, timeout: float = 15.0) -> int:
+        if self.session is not None:
+            try:
+                r = self.session.head(url, impersonate=IMPERSONATE,  # type: ignore
+                                      timeout=timeout, allow_redirects=True)
+                if r.status_code == 200:
+                    cl = r.headers.get("Content-Length", "")
+                    if cl.isdigit():
+                        return int(cl)
+            except Exception:
+                pass
+            # cffi path gave no size — don't touch self._pool (it doesn't exist)
+            return 0
+        assert self._pool is not None
+        try:
+            r2 = self._pool.request("HEAD", url, redirect=True,
+                                    timeout=urllib3.Timeout(connect=10, read=timeout))
+            if r2.status == 200:
+                cl = r2.headers.get("Content-Length", "")
+                if cl.isdigit():
+                    return int(cl)
+        except Exception:
+            pass
+        return 0
+
+
+# ─────────────────────────────────────────────────────────────────
+#  HLS / m3u8 downloader
+# ─────────────────────────────────────────────────────────────────
+
+class HLSDownloader:
+    """
+    Parse master/media playlist, stream every .ts segment to disk concurrently.
+    Default 4 threads — safe on 2 GB RAM (4 × ~4 MB = ~16 MB peak working set).
+    """
+
+    def __init__(self, threads: int = 4, fetcher: Optional[Fetcher] = None):
+        self.threads = threads
+        self.fetcher = fetcher or Fetcher(max_pool=threads + 2)
+
+    # ── playlist parsing ──────────────────────────────────────────
+    def _parse_segments(self, playlist_url: str) -> list[tuple[str, float]]:
+        txt = self.fetcher.text(playlist_url)
+
+        if "#EXT-X-STREAM-INF" in txt:
+            # master playlist — pick highest bandwidth variant
+            variants: list[tuple[int, str]] = []
+            base = playlist_url.rsplit("/", 1)[0] + "/"
+            lines = txt.splitlines()
+            for i, line in enumerate(lines):
+                if not line.startswith("#EXT-X-STREAM-INF"):
+                    continue
+                bw_m = re.search(r'BANDWIDTH=(\d+)', line)
+                bw   = int(bw_m.group(1)) if bw_m else 0
+                for nxt in lines[i + 1:]:
+                    nxt = nxt.strip()
+                    if nxt and not nxt.startswith("#"):
+                        variants.append((bw, nxt if "://" in nxt else base + nxt))
+                        break
+            if not variants:
+                raise IOError("master playlist: no variants found")
+            best = sorted(variants, key=lambda x: -x[0])[0][1]
+            return self._parse_segments(best)
+
+        # media playlist
+        out:  list[tuple[str, float]] = []
+        base  = playlist_url.rsplit("/", 1)[0] + "/"
+        dur   = 0.0
+        for line in txt.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            if line.startswith("#EXTINF:"):
+                try:
+                    dur = float(line.split(":", 1)[1].rstrip(",").split()[0])
+                except (ValueError, IndexError):
+                    dur = 0.0
+            elif line.startswith("#"):
+                continue
+            else:
+                url = line if "://" in line else base + line
+                out.append((url, dur))
+                dur = 0.0
+        return out
+
+    # ── main entry ────────────────────────────────────────────────
+    def download(self, m3u8_url: str, out_path: Path,
+                 progress: ProgressFn = _noop_progress) -> Path:
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        segments = self._parse_segments(m3u8_url)
+        if not segments:
+            raise IOError(f"no segments found in {m3u8_url}")
+
+        # rough size estimate: 2 Mbit/s avg × duration
+        total_est = max(int(sum(d for _, d in segments) * 250_000), 1)
+        progress(0, total_est, 0.0)
+
+        # prefer ffmpeg — zero extra RAM, fastest possible
+        if shutil.which("ffmpeg"):
+            return self._download_ffmpeg(m3u8_url, out_path, progress)
+
+        return self._download_manual(segments, out_path, total_est, progress)
+
+    # ── ffmpeg path ───────────────────────────────────────────────
+    def _download_ffmpeg(self, m3u8_url: str, out_path: Path,
+                         progress: ProgressFn) -> Path:
+        import subprocess
+        cmd = [
+            "ffmpeg", "-y", "-loglevel", "error",
+            "-headers", f"User-Agent: {UA}\r\nReferer: {REFERER}\r\n",
+            "-i", m3u8_url,
+            "-c", "copy",
+            str(out_path),
+        ]
+        proc = subprocess.Popen(cmd)
+        proc.wait()
+        if proc.returncode != 0:
+            raise IOError(f"ffmpeg exited {proc.returncode}")
+        sz = out_path.stat().st_size
+        progress(sz, sz, 0.0)
+        return out_path
+
+    # ── manual threaded path ──────────────────────────────────────
+    def _download_manual(self, segments: list[tuple[str, float]],
+                         out_path: Path, total_est: int,
+                         progress: ProgressFn) -> Path:
+        tmp_dir = out_path.with_suffix(".parts")
+        if tmp_dir.exists():
+            shutil.rmtree(tmp_dir)
+        tmp_dir.mkdir(parents=True, exist_ok=True)
+
+        bytes_done = 0
+        t0    = time.time()
+        lock  = threading.Lock()
+        errors: list[str] = []
+
+        def fetch_seg(args: tuple[int, str, float]) -> None:
+            nonlocal bytes_done
+            idx, url, _dur = args
+            seg_path = tmp_dir / f"{idx:06d}.ts"
+
+            # resume: skip already-fetched segments
+            if seg_path.exists() and seg_path.stat().st_size > 0:
+                with lock:
+                    bytes_done += seg_path.stat().st_size
+                return
+
+            for attempt in range(5):
+                try:
+                    written = self.fetcher.stream_to_file(url, seg_path, timeout=120.0)
+                    with lock:
+                        bytes_done += written
+                        elapsed = time.time() - t0 or 0.001
+                        progress(bytes_done, total_est, bytes_done / elapsed)
+                    return
+                except Exception as e:
+                    if seg_path.exists():
+                        seg_path.unlink(missing_ok=True)
+                    time.sleep(0.5 * (attempt + 1))
+            errors.append(url)
+
+        indexed = [(i, u, d) for i, (u, d) in enumerate(segments)]
+        with ThreadPoolExecutor(max_workers=self.threads) as pool:
+            futs = {pool.submit(fetch_seg, t): t for t in indexed}
+            for f in as_completed(futs):
+                try:
+                    f.result()
+                except Exception as e:
+                    errors.append(str(e))
+
+        if errors:
+            print(f"\n[!] {len(errors)} segment(s) failed — file may be incomplete")
+
+        # stream-concat in order — 256 KB at a time, minimal RAM
+        with out_path.open("wb") as outf:
+            for i in range(len(segments)):
+                seg = tmp_dir / f"{i:06d}.ts"
+                if not seg.exists():
+                    continue
+                with seg.open("rb") as sf:
+                    while True:
+                        chunk = sf.read(_STREAM_CHUNK)
+                        if not chunk:
+                            break
+                        outf.write(chunk)
+                seg.unlink()
+
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        sz = out_path.stat().st_size
+        progress(sz, sz, 0.0)
+        return out_path
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Direct MP4 chunked downloader
+# ─────────────────────────────────────────────────────────────────
+
+class DirectDownloader:
+    """
+    Range-request parallel download for direct MP4 URLs.
+    Each chunk is streamed directly to the correct file offset.
+    """
+
+    def __init__(self, threads: int = 4, fetcher: Optional[Fetcher] = None):
+        self.threads = threads
+        self.fetcher = fetcher or Fetcher(max_pool=threads + 2)
+
+    def download(self, url: str, out_path: Path,
+                 progress: ProgressFn = _noop_progress) -> Path:
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        total = self.fetcher.head_size(url)
+        if not total:
+            return self._single_stream(url, out_path, progress)
+
+        # chunk size: ensure at most 4 MB per chunk to keep RAM bounded
+        per_thread = max(4 * 1024 * 1024, total // (self.threads * 4))
+        chunk_size = min(per_thread, 8 * 1024 * 1024)
+        ranges: list[tuple[int, int]] = []
+        pos = 0
+        while pos < total:
+            end = min(pos + chunk_size - 1, total - 1)
+            ranges.append((pos, end))
+            pos = end + 1
+
+        tmp = out_path.with_suffix(out_path.suffix + ".part")
+        # pre-allocate with zeros so we can seek-write safely
+        with tmp.open("wb") as f:
+            f.seek(total - 1)
+            f.write(b"\x00")
+
+        bytes_done = 0
+        t0   = time.time()
+        lock = threading.Lock()
+
+        def pull(rng: tuple[int, int]) -> None:
+            nonlocal bytes_done
+            start, end = rng
+            for attempt in range(5):
+                try:
+                    hdrs = {
+                        "Range": f"bytes={start}-{end}",
+                        "User-Agent": UA,
+                        "Referer": REFERER,
+                    }
+                    if _HAS_CFFI and self.fetcher.session is not None:
+                        r = self.fetcher.session.get(  # type: ignore
+                            url, impersonate=IMPERSONATE,
+                            headers=hdrs, timeout=120,
+                        )
+                        if r.status_code not in (200, 206):
+                            raise IOError(f"range status {r.status_code}")
+                        data = r.content
+                    else:
+                        assert self.fetcher._pool is not None
+                        r2 = self.fetcher._pool.request(
+                            "GET", url, headers=hdrs,
+                            timeout=urllib3.Timeout(connect=10, read=120),
+                            preload_content=True,
+                        )
+                        if r2.status not in (200, 206):
+                            raise IOError(f"range status {r2.status}")
+                        data = r2.data
+
+                    with open(tmp, "r+b") as f:
+                        f.seek(start)
+                        f.write(data)
+                    with lock:
+                        bytes_done += len(data)
+                        elapsed = time.time() - t0 or 0.001
+                        progress(bytes_done, total, bytes_done / elapsed)
+                    return
+                except Exception:
+                    time.sleep(0.5 * (attempt + 1))
+            raise IOError(f"range {start}-{end} failed after 5 attempts")
+
+        with ThreadPoolExecutor(max_workers=self.threads) as pool:
+            list(pool.map(pull, ranges))
+
+        tmp.rename(out_path)
+        progress(total, total, 0.0)
+        return out_path
+
+    def _single_stream(self, url: str, out_path: Path,
+                       progress: ProgressFn) -> Path:
+        """No Content-Length — stream directly to disk."""
+        written = self.fetcher.stream_to_file(url, out_path, timeout=600.0)
+        progress(written, written, 0.0)
+        return out_path
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Helpers
+# ─────────────────────────────────────────────────────────────────
+
+def sanitize_filename(name: str, max_len: int = 120) -> str:
+    name = re.sub(r'[\\/*?:"<>|\r\n]+', "_", name).strip(" ._")
+    return (name or "untitled")[:max_len]
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Public entrypoint
+# ─────────────────────────────────────────────────────────────────
+
+def download_video(video, out_dir: Path, threads: int = 4,
+                   preferred_resolution: Optional[str] = None,
+                   progress: ProgressFn = _noop_progress) -> Path:
+    """Download a Video object.  threads=4 by default (safe on 2 GB RAM)."""
+    safe     = sanitize_filename(f"{video.code}_{video.title}")
+    out_path = out_dir / f"{safe}.mp4"
+
+    m3u8 = getattr(video, "m3u8", "") or ""
+    if not m3u8:
+        raise IOError(f"no m3u8 source found for {video.code}")
+
+    if preferred_resolution:
+        from .scraper import MissAV
+        m        = MissAV()
+        variants = m.resolutions(m3u8)
+        pick     = next(
+            (v for v in variants
+             if v["resolution"].endswith(preferred_resolution)), None,
+        )
+        if pick and pick.get("url"):
+            m3u8 = pick["url"]
+
+    hls = HLSDownloader(threads=threads)
+    return hls.download(m3u8, out_path, progress=progress)

jav_dl_tmux/scraper.py

@@ -0,0 +1,437 @@
+"""
+Scraper — MissAV endpoints, live search, recent uploads, single-video metadata.
+
+MissAV sits behind Cloudflare.  curl_cffi (Chrome TLS impersonation) bypasses it
+cleanly when available.  On armv7l / Termux where curl_cffi won't build, we fall
+back to urllib3 with realistic headers — good enough for most requests.
+
+Endpoints:
+    GET https://missav.live/en                     -> recent uploads
+    GET https://missav.live/en/search/{query}      -> search results
+    GET https://missav.live/en/{slug}              -> single video page (m3u8 here)
+"""
+from __future__ import annotations
+
+import re
+import time
+import base64
+import binascii
+from typing import Optional
+from urllib.parse import urljoin, quote_plus
+
+# ── optional Chrome-TLS backend ──────────────────────────────────────────────
+try:
+    from curl_cffi import requests as _cffi  # type: ignore
+    _HAS_CFFI = True
+except Exception:
+    _HAS_CFFI = False
+
+import urllib3
+from urllib3.exceptions import HTTPError
+from urllib3.util.retry import Retry
+from urllib3.util.ssl_ import create_urllib3_context
+
+# ── constants ─────────────────────────────────────────────────────────────────
+UA = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+)
+BASE = "https://missav.live"
+IMPERSONATE = "chrome120"
+
+_HEADERS = {
+    "User-Agent": UA,
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Referer": BASE + "/",
+    "DNT": "1",
+    "Upgrade-Insecure-Requests": "1",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-User": "?1",
+    "Sec-Ch-Ua": '"Not_A brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": '"Windows"',
+}
+
+_RETRY = Retry(
+    total=4,
+    backoff_factor=0.5,
+    status_forcelist={429, 500, 502, 503, 504},
+    allowed_methods={"GET", "HEAD"},
+    raise_on_status=False,
+)
+
+
+# ─────────────────────────────────────────────────────────────────
+#  HTTP wrapper
+# ─────────────────────────────────────────────────────────────────
+
+class Http:
+    """
+    Chrome-impersonating session when curl_cffi is available.
+    Falls back to urllib3 with realistic headers on armv7l / unsupported arches.
+    """
+
+    def __init__(self, retries: int = 4, timeout: float = 25.0):
+        self.timeout = timeout
+        self._retries = retries
+        self._min_delay = 1.5
+        self._last_call = 0.0
+
+        if _HAS_CFFI:
+            self._session = _cffi.Session()
+            self._session.headers.update(_HEADERS)
+            self._pool: Optional[urllib3.PoolManager] = None
+            self._warmup()
+        else:
+            self._session = None
+            ctx = create_urllib3_context()
+            ctx.minimum_version = 0x0303  # TLS 1.2
+            self._pool = urllib3.PoolManager(
+                num_pools=6,
+                maxsize=4,
+                headers=_HEADERS,
+                retries=_RETRY,
+                timeout=urllib3.Timeout(connect=15, read=timeout),
+                ssl_context=ctx,
+            )
+
+    # ── warmup ────────────────────────────────────────────────────
+    def _warmup(self) -> None:
+        if self._session is None:
+            return
+        for url in (BASE + "/", BASE + "/en"):
+            try:
+                self._session.get(url, impersonate=IMPERSONATE, timeout=self.timeout)
+                time.sleep(0.8)
+            except Exception:
+                pass
+
+    # ── throttle ──────────────────────────────────────────────────
+    def _throttle(self) -> None:
+        elapsed = time.time() - self._last_call
+        if elapsed < self._min_delay:
+            time.sleep(self._min_delay - elapsed)
+        self._last_call = time.time()
+
+    @staticmethod
+    def _is_challenge(body: str) -> bool:
+        return (
+            "Just a moment" in body[:600]
+            or "cf-chl-bypass" in body
+            or "<title>Just a moment" in body
+        )
+
+    # ── core fetch ────────────────────────────────────────────────
+    def _fetch(self, url: str, method: str = "GET") -> str:
+        last_err: Exception = HTTPError(f"no attempts made for {url}")
+
+        extra: dict = {}
+        if "/search/" in url:
+            extra["Referer"] = BASE + "/en"
+        elif re.search(r"/en/[a-z0-9\-]+$", url):
+            extra["Referer"] = BASE + "/en"
+
+        for attempt in range(self._retries):
+            self._throttle()
+            try:
+                if self._session is not None:
+                    fn = self._session.get if method == "GET" else self._session.head
+                    r = fn(
+                        url,
+                        impersonate=IMPERSONATE,
+                        timeout=self.timeout,
+                        headers=extra,
+                    )
+                    if r.status_code != 200:
+                        last_err = HTTPError(f"HTTP {r.status_code} for {url}")
+                        time.sleep(1.5 * (attempt + 1))
+                        continue
+                    if self._is_challenge(r.text):
+                        last_err = HTTPError(f"CF challenge for {url}")
+                        time.sleep(2.0 * (attempt + 1))
+                        if attempt == 1:
+                            self._warmup()
+                        continue
+                    return r.text
+                else:
+                    assert self._pool is not None
+                    r2 = self._pool.request(method, url, headers=extra,
+                                            timeout=urllib3.Timeout(connect=15,
+                                                                    read=self.timeout))
+                    if r2.status != 200:
+                        last_err = HTTPError(f"HTTP {r2.status} for {url}")
+                        time.sleep(0.8 * (attempt + 1))
+                        continue
+                    body = r2.data.decode("utf-8", errors="replace")
+                    if self._is_challenge(body):
+                        last_err = HTTPError(f"CF challenge for {url}")
+                        time.sleep(1.2 * (attempt + 1))
+                        continue
+                    return body
+            except (HTTPError, IOError) as e:
+                last_err = e
+                time.sleep(0.8 * (attempt + 1))
+            except Exception as e:
+                last_err = IOError(str(e))
+                time.sleep(1.0 * (attempt + 1))
+
+        raise last_err
+
+    def get_text(self, url: str) -> str:
+        return self._fetch(url, "GET")
+
+    def get_bytes(self, url: str, referer: str = BASE + "/") -> bytes:
+        """Fetch raw bytes — used for thumbnails / m3u8 binary payloads."""
+        last_err: Exception = HTTPError(f"no attempts for {url}")
+        hdrs = {"Referer": referer}
+
+        for attempt in range(self._retries):
+            self._throttle()
+            try:
+                if self._session is not None:
+                    r = self._session.get(
+                        url, impersonate=IMPERSONATE,
+                        timeout=self.timeout, headers=hdrs,
+                    )
+                    if r.status_code != 200:
+                        last_err = HTTPError(f"HTTP {r.status_code} for {url}")
+                        time.sleep(0.5 * (attempt + 1))
+                        continue
+                    return r.content
+                else:
+                    assert self._pool is not None
+                    r2 = self._pool.request("GET", url, headers=hdrs,
+                                            timeout=urllib3.Timeout(connect=15,
+                                                                    read=self.timeout))
+                    if r2.status != 200:
+                        last_err = HTTPError(f"HTTP {r2.status} for {url}")
+                        time.sleep(0.5 * (attempt + 1))
+                        continue
+                    return r2.data
+            except Exception as e:
+                last_err = IOError(str(e))
+                time.sleep(0.5 * (attempt + 1))
+
+        raise last_err
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Data containers
+# ─────────────────────────────────────────────────────────────────
+
+class Video:
+    __slots__ = ("title", "slug", "url", "thumb", "duration", "date",
+                 "actresses", "tags", "code", "size_hint", "m3u8")
+
+    def __init__(self, **kw):
+        for k in self.__slots__:
+            setattr(self, k, kw.get(k))
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Regex patterns
+# ─────────────────────────────────────────────────────────────────
+
+CARD_RE = re.compile(
+    r'<a[^>]+href="https://missav\.live/en/([a-z0-9\-]+)"[^>]*alt="[^"]*"\s*>\s*'
+    r'([A-Z]{2,5}-\d{2,5}[^<]*)',
+    re.IGNORECASE | re.DOTALL,
+)
+CARD_THUMB_RE = re.compile(
+    r'<img[^>]+(?:src|data-src|data-original)="([^"]+\.(?:jpg|jpeg|png|webp))"',
+    re.IGNORECASE,
+)
+CARD_DUR_RE  = re.compile(r'>\s*(\d{1,3}:\d{2}(?::\d{2})?)\s*<')
+DATE_RE      = re.compile(r'(\d{4}-\d{2}-\d{2})')
+DURATION_RE  = re.compile(r'(\d{1,3}):(\d{2})')
+CODE_RE      = re.compile(r'\b([A-Z]{2,5}-\d{2,5})\b')
+M3U8_URL_RE  = re.compile(r'https?://[^\s"\'<>)]+?\.m3u8(?:\?[^\s"\'<>)]*)?', re.IGNORECASE)
+M3U8_B64_RE  = re.compile(r'atob\(["\']([A-Za-z0-9+/=]{20,})["\']\)')
+M3U8_VAR_RE  = re.compile(
+    r'(?:videoSource|videoUrl|streamUrl|playerUrl|m3u8Url)\s*[:=]\s*["\']([^"\']+)["\']'
+)
+
+
+def _strip_tags(s: str) -> str:
+    return re.sub(r'<[^>]+>', '', s).strip()
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Parsers
+# ─────────────────────────────────────────────────────────────────
+
+def parse_video(html: str, slug: str, base: str = BASE) -> Video:
+    og_title = re.search(r'<meta property="og:title" content="([^"]+)"', html)
+    tw_title = re.search(r'<meta name="twitter:title" content="([^"]+)"', html)
+    title = ""
+    if og_title:
+        title = og_title.group(1)
+    elif tw_title:
+        title = tw_title.group(1)
+    else:
+        h1_m = re.search(r'<h1[^>]*>(.*?)</h1>', html, re.IGNORECASE | re.DOTALL)
+        if h1_m:
+            title = _strip_tags(h1_m.group(1))
+    title = _strip_tags(title) or slug.replace("-", " ").title()
+
+    code_m = CODE_RE.search(title)
+    code = code_m.group(1) if code_m else slug.upper()
+
+    thumb = ""
+    for pat in (r'<meta property="og:image" content="([^"]+)"',
+                r'<meta name="twitter:image" content="([^"]+)"'):
+        m = re.search(pat, html)
+        if m:
+            thumb = m.group(1)
+            break
+
+    duration = None
+    dur_m = DURATION_RE.search(html)
+    if dur_m:
+        duration = int(dur_m.group(1)) * 60 + int(dur_m.group(2))
+
+    date_m = DATE_RE.search(html)
+    date = date_m.group(1) if date_m else ""
+
+    return Video(
+        title=title, slug=slug, code=code,
+        url=f"{base}/en/{slug}",
+        thumb=thumb, duration=duration, date=date,
+        actresses=[], tags=[], size_hint=None,
+    )
+
+
+def parse_listing(html: str, base: str = BASE) -> list[Video]:
+    out: dict[str, Video] = {}
+
+    for m in CARD_RE.finditer(html):
+        slug = m.group(1)
+        anchor_text = _strip_tags(m.group(2))
+        if not slug or slug in out:
+            continue
+
+        code_m = re.match(r'^([A-Z]{2,5}-\d{2,5})\s*(.*)', anchor_text)
+        if code_m:
+            code  = code_m.group(1)
+            title = code_m.group(2).strip()
+        else:
+            code  = slug.upper()
+            title = anchor_text
+
+        chunk = html[max(0, m.start() - 2500): m.end() + 500]
+
+        thumb_m = CARD_THUMB_RE.search(chunk)
+        thumb   = thumb_m.group(1) if thumb_m else ""
+        if thumb and not thumb.startswith("http"):
+            thumb = urljoin(base, thumb)
+
+        dur_m    = CARD_DUR_RE.search(chunk)
+        duration = None
+        if dur_m:
+            parts = [int(p) for p in dur_m.group(1).split(":")]
+            if len(parts) == 3:
+                duration = parts[0] * 3600 + parts[1] * 60 + parts[2]
+            elif len(parts) == 2:
+                duration = parts[0] * 60 + parts[1]
+
+        date_m = DATE_RE.search(chunk)
+        out[slug] = Video(
+            title=title or slug, slug=slug, code=code,
+            url=f"{base}/en/{slug}",
+            thumb=thumb, duration=duration,
+            date=date_m.group(1) if date_m else "",
+        )
+
+    if not out:
+        for m in re.finditer(r'href="https://missav\.live/en/([a-z0-9\-]+)"', html):
+            slug = m.group(1)
+            if slug in out:
+                continue
+            if slug in ("vip", "actresses", "genres", "makers", "klive", "clive", "saved"):
+                continue
+            out[slug] = Video(
+                title=slug, slug=slug, code=slug.upper(),
+                url=f"{base}/en/{slug}", thumb="", date="",
+            )
+
+    return list(out.values())
+
+
+# ─────────────────────────────────────────────────────────────────
+#  m3u8 extractor
+# ─────────────────────────────────────────────────────────────────
+
+def _find_m3u8(html: str) -> str:
+    for m in M3U8_URL_RE.finditer(html):
+        return m.group(0)
+    b64 = M3U8_B64_RE.search(html)
+    if b64:
+        try:
+            return base64.b64decode(b64.group(1)).decode("utf-8", errors="replace")
+        except (binascii.Error, ValueError):
+            pass
+    varm = M3U8_VAR_RE.search(html)
+    if varm:
+        return varm.group(1)
+    return ""
+
+
+# ─────────────────────────────────────────────────────────────────
+#  Public API
+# ─────────────────────────────────────────────────────────────────
+
+class MissAV:
+    """Main scraper object."""
+
+    def __init__(self, http: Optional[Http] = None):
+        self.http = http or Http()
+
+    def search(self, query: str) -> list[Video]:
+        if not query.strip():
+            return self.recent()
+        url = f"{BASE}/en/search/{quote_plus(query)}"
+        try:
+            html = self.http.get_text(url)
+        except Exception:
+            return []
+        return parse_listing(html)
+
+    def recent(self, page: int = 1) -> list[Video]:
+        url = BASE if page == 1 else f"{BASE}/en?page={page}"
+        try:
+            html = self.http.get_text(url)
+        except Exception:
+            return []
+        return parse_listing(html)
+
+    def video(self, slug: str) -> Video:
+        url  = f"{BASE}/en/{slug}"
+        html = self.http.get_text(url)
+        v    = parse_video(html, slug)
+        v.m3u8 = _find_m3u8(html)
+        return v
+
+    def resolutions(self, m3u8_url: str) -> list[dict]:
+        try:
+            txt = self.http.get_text(m3u8_url)
+        except Exception:
+            return []
+        out: list[dict] = []
+        base = m3u8_url.rsplit("/", 1)[0] + "/"
+        for line in txt.splitlines():
+            if line.startswith("#EXT-X-STREAM-INF"):
+                attrs = dict(re.findall(r'([A-Z\-]+)=("[^"]+"|\d+)', line))
+                res   = attrs.get("RESOLUTION", "?").strip('"')
+                bw    = attrs.get("BANDWIDTH", "?")
+                try:
+                    bw = int(bw)
+                except (TypeError, ValueError):
+                    pass
+                out.append({"resolution": res, "bandwidth": bw, "url": None})
+            elif line.strip() and not line.startswith("#") and out:
+                out[-1]["url"] = urljoin(base, line.strip())
+        return out

java_extention-1.1.1.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: java_extention
+Version: 1.1.1
+Summary: MissAV HLS downloader. armv7l/Termux safe.
+Requires-Python: >=3.9
+Requires-Dist: rich>=13.0
+Requires-Dist: urllib3>=2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License

java_extention-1.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+jav_dl_tmux/__init__.py,sha256=6VUkFXkixUir6dJ9CWMqL2FjxZEliFJhEZa6Ixfjgq8,133
+jav_dl_tmux/__main__.py,sha256=1q_oFO1yRT7d-vCKepBvwKbnHnW0Sd6gFlEi-P_Pr70,11213
+jav_dl_tmux/scraper.py,sha256=prT_Fe75oz_9XvBxM3QQfcczZYoJVMyJGWcaNWywUd0,17579
+jav_dl_tmux/downloader.py,sha256=_IDYQCasDqkueFgO5NoV8_lBzlbxBihPY_I85zCzl4Q,20598
+java_extention-1.1.1.dist-info/METADATA,sha256=KLwMB5c-LSylxcX6RxQeoqqZ1cSX-0Hu_8TZAf039Nk,321
+java_extention-1.1.1.dist-info/WHEEL,sha256=2jHdxKWnCIK_lI5LTqwkSmjgOUSsTtjdBrux51aJqKg,77
+java_extention-1.1.1.dist-info/entry_points.txt,sha256=EO58EgQkmXdZyUBuHbA07YVBqSxy7pn5AA8-pXFwKjo,58
+java_extention-1.1.1.dist-info/RECORD,,

java_extention-1.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: manual
+Root-Is-Purelib: true
+Tag: py3-none-any

java_extention-1.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jav-dl-tmux = jav_dl_tmux.__main__:main