java2-extention 1.0.0__py3-none-any.whl

java2_extention/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

java2_extention/__main__.py

@@ -0,0 +1,325 @@
+"""
+java2 — freepornvideos.xxx search + threaded downloader
+
+Usage:
+  java2                    # interactive menu
+  java2 "milf"             # search immediately
+  java2 --recent           # browse recent uploads
+  java2 --recent -p 2      # recent page 2
+  java2 -t 4               # 4 download threads
+  java2 -o ~/dl            # custom output dir
+  java2 --clear-cache      # wipe search cache
+"""
+from __future__ import annotations
+
+import re
+import sys
+import time
+import argparse
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel   import Panel
+from rich.table   import Table
+from rich.live    import Live
+from rich.text    import Text
+from rich         import box
+
+from .scraper    import FPV, Video, VideoEntry
+from .downloader import download_direct, download_hls
+from . import cache  as _cache
+from . import config as _config
+from .http_client import HttpClient
+
+console = Console(stderr=False)
+VERSION = "1.0.0"
+
+_cfg             = _config.load()
+_DEFAULT_THREADS = _cfg["threads"]
+DOWNLOAD_DIR     = Path(_cfg["download_dir"]).expanduser()
+
+
+def _banner() -> None:
+    console.print(Panel.fit(
+        f"[bold cyan]java2[/bold cyan]  [dim]v{VERSION}[/dim]\n"
+        f"[dim]freepornvideos.xxx · direct MP4 + HLS · {_DEFAULT_THREADS} threads · stream-to-disk[/dim]",
+        border_style="cyan",
+    ))
+
+
+def _ask(prompt: str, lo: int = 1, hi: int = 99, default: int = 1) -> int:
+    while True:
+        try:
+            raw = input(f"\n  {prompt} [{lo}-{hi}] (default {default}): ").strip()
+            if raw == "":
+                return default - 1
+            n = int(raw)
+            if lo <= n <= hi:
+                return n - 1
+            console.print(f"  [red]Enter a number between {lo} and {hi}[/red]")
+        except (ValueError, EOFError):
+            return default - 1
+
+
+def _ask_str(prompt: str, default: str = "") -> str:
+    try:
+        hint = f" [{default}]" if default else ""
+        val  = input(f"\n  {prompt}{hint}: ").strip()
+        return val if val else default
+    except EOFError:
+        return default
+
+
+def _show_results(videos: list[Video], title: str = "Results") -> None:
+    table = Table(
+        show_header=True, header_style="bold cyan",
+        box=box.SIMPLE_HEAVY, show_lines=False, title=title,
+        title_style="bold white",
+    )
+    table.add_column("#",        style="bold dim",   width=4)
+    table.add_column("ID",       style="bold yellow", width=10)
+    table.add_column("Title",    min_width=36)
+    table.add_column("Duration", width=8, style="dim")
+
+    for i, v in enumerate(videos, 1):
+        table.add_row(str(i), v.video_id, (v.title or "")[:60], v.duration or "—")
+    console.print(table)
+
+
+def _show_qualities(entries: list[dict]) -> None:
+    table = Table(
+        show_header=True, header_style="bold magenta",
+        box=box.SIMPLE, title="Available qualities",
+    )
+    table.add_column("#",       width=4)
+    table.add_column("Quality", width=8)
+    table.add_column("Format",  width=8)
+    table.add_column("URL",     no_wrap=False, overflow="fold")
+
+    for i, e in enumerate(entries, 1):
+        table.add_row(
+            str(i),
+            (e.get("quality") or "?").upper(),
+            (e.get("ext") or "?").upper(),
+            e.get("url", "")[:80],
+        )
+    console.print(table)
+
+
+def _render_bar(done: int, total: int, speed: float, label: str = "Downloading") -> Text:
+    if total and total > 0:
+        pct   = min(100, int(done * 100 / total))
+    else:
+        pct   = 0
+    fill  = "█" * (pct // 4)
+    empty = "░" * (25 - pct // 4)
+    spd   = (f"{speed/1_000_000:.2f} MB/s" if speed >= 1_000_000
+             else f"{speed/1_000:.0f} KB/s" if speed >= 1_000
+             else f"{speed:.0f} B/s")
+    t = Text()
+    t.append(f"{label}  ", style="bold white")
+    t.append(fill,  style="cyan")
+    t.append(empty, style="dim")
+    t.append(f"  {pct:3d}%  " if total else f"  {done//1_048_576} MB  ", style="bold white")
+    t.append(f"  {spd}", style="green")
+    return t
+
+
+def _search_cached(api: FPV, query: str) -> list[Video]:
+    cached = _cache.get(query)
+    if cached:
+        console.print(f"  [dim](cache hit for '{query}')[/dim]")
+        return [Video.from_dict(d) for d in cached]
+
+    console.print(f"  [cyan]Searching:[/cyan] {query}")
+    results = api.search(query)
+    console.print(f"  [green]→ {len(results)} result(s)[/green]")
+
+    if results:
+        _cache.put(query, [v.to_dict() for v in results])
+    return results
+
+
+def _do_download(
+    api:     FPV,
+    video:   Video,
+    out_dir: Path,
+    threads: int,
+) -> None:
+    console.print(f"\n  [cyan]Fetching video page…[/cyan]")
+    video = api.video_details(video)
+
+    if not video.entries:
+        console.print("\n  [bold red]✗ No video URLs found on page.[/bold red]")
+        console.print(f"  [dim]URL:[/dim] {video.page_url}")
+        console.print("  [dim]Page may use JS player — try visiting it in a browser.[/dim]")
+        return
+
+    console.print(Panel(
+        f"[bold yellow]{video.video_id}[/bold yellow]  {video.title}\n"
+        f"[dim]Page:[/dim] {video.page_url}",
+        border_style="dim",
+    ))
+
+    # filter to HLS or direct files only
+    usable = [e for e in video.entries if e.get("ext") in ("mp4", "webm", "m3u8")]
+    if not usable:
+        usable = video.entries  # show everything if nothing direct
+
+    _show_qualities(usable)
+    if not usable:
+        console.print("  [red]✗ No downloadable URLs.[/red]")
+        return
+
+    choice = _ask("Pick quality", 1, len(usable), 1)
+    entry  = usable[choice]
+
+    url = entry.get("url", "")
+    ext = entry.get("ext", "mp4")
+    q   = (entry.get("quality") or "unknown").lower()
+
+    safe_title = re.sub(r'[<>:"/\\|?*\x00-\x1f]', "_", video.title or video.video_id)[:60]
+    fname      = f"{video.video_id}_{q}.{ext if ext != 'm3u8' else 'mp4'}"
+    out_path   = out_dir / fname
+
+    console.print(f"\n  [green]Downloading:[/green] {fname}")
+    console.print(f"  [dim]→ {out_path}[/dim]")
+
+    bar_text = Text("Starting…")
+
+    def _prog(done: int, total: int, speed: float) -> None:
+        nonlocal bar_text
+        bar_text = _render_bar(done, total, speed)
+
+    try:
+        with Live(bar_text, console=console, refresh_per_second=4) as live:
+            def _prog2(done: int, total: int, speed: float) -> None:
+                live.update(_render_bar(done, total, speed))
+
+            if ext == "m3u8":
+                download_hls(url, out_path, threads=threads, progress=_prog2)
+            else:
+                download_direct(url, out_path, referer=video.page_url, threads=threads, progress=_prog2)
+
+    except KeyboardInterrupt:
+        console.print("\n  [yellow]Interrupted.[/yellow]")
+        return
+    except Exception as e:
+        console.print(f"\n  [bold red]✗ Download failed:[/bold red] {e}")
+        return
+
+    if out_path.exists():
+        size = out_path.stat().st_size
+        console.print(Panel.fit(
+            f"✓ Done!\n"
+            f"File: {out_path}\n"
+            f"Size:  {size/1_048_576:.1f} MB  |  Quality: {q}",
+            border_style="green",
+        ))
+    else:
+        console.print("  [red]✗ Output file not found after download.[/red]")
+
+
+def run(args: argparse.Namespace) -> None:
+    cfg     = _config.load()
+    http    = HttpClient(timeout=30.0, min_delay=3.0)
+    api     = FPV(http)
+    out_dir = Path(args.output if args.output != str(DOWNLOAD_DIR)
+                   else cfg["download_dir"]).expanduser().resolve()
+    if args.threads == _DEFAULT_THREADS:
+        args.threads = cfg["threads"]
+
+    if args.recent:
+        page = getattr(args, "page", 1) or 1
+        console.print(f"  [cyan]Loading recent uploads (page {page})…[/cyan]")
+        results = api.recent(page=page)
+        console.print(f"  [green]→ {len(results)} video(s)[/green]")
+        if not results:
+            console.print("  [red]✗ No recent results. Check connection.[/red]")
+            return
+        _show_results(results, f"Recent (page {page})")
+        selected = results[_ask("Pick video", 1, len(results), 1)]
+
+    elif args.query:
+        results = _search_cached(api, args.query)
+        if not results:
+            console.print(f"\n  [red]✗ No results for '{args.query}'[/red]")
+            console.print("  [dim]Tip: try simpler keywords like 'milf', 'amateur', etc.[/dim]")
+            return
+        _show_results(results, f"'{args.query}'  ({len(results)} result(s))")
+        if len(results) == 1:
+            selected = results[0]
+            console.print(f"  [green]Auto-selected:[/green] {selected.title}")
+        else:
+            selected = results[_ask("Pick video", 1, len(results), 1)]
+
+    else:
+        console.print("\n  [bold]1.[/bold] Search")
+        console.print("  [bold]2.[/bold] Recent uploads")
+        console.print("  [bold]3.[/bold] Settings")
+        console.print("  [bold]4.[/bold] Clear cache\n")
+        choice = _ask("Select", 1, 4, 1)
+
+        if choice == 2:
+            _cfg2 = _config.edit_interactive()
+            console.print(f"  [dim]Download dir:[/dim] {_cfg2['download_dir']}")
+            console.print(f"  [dim]Threads:[/dim]      {_cfg2['threads']}")
+            return
+
+        if choice == 3:
+            _cache.clear()
+            console.print("  [green]✓ Cache cleared.[/green]")
+            return
+
+        if choice == 1:
+            # 2. Recent uploads
+            console.print("  [cyan]Loading recent uploads…[/cyan]")
+            results = api.recent()
+            console.print(f"  [green]→ {len(results)} video(s)[/green]")
+        else:
+            # 1. Search (choice == 0)
+            q = _ask_str("Search query")
+            if not q:
+                return
+            results = _search_cached(api, q)
+
+        if not results:
+            console.print("  [red]✗ No results.[/red]")
+            return
+
+        _show_results(results)
+        selected = results[_ask("Pick video", 1, len(results), 1)]
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    _do_download(api, selected, out_dir, threads=args.threads)
+
+
+def main() -> None:
+    _banner()
+
+    parser = argparse.ArgumentParser(
+        prog="java2",
+        description="freepornvideos.xxx downloader — direct MP4 + HLS, Termux/2GB safe",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument("query",    nargs="?", default="",          help="Search query")
+    parser.add_argument("--recent", action="store_true",            help="Browse recent uploads")
+    parser.add_argument("-p", "--page", type=int, default=1,        help="Recent page number (default 1)")
+    parser.add_argument("-t", "--threads", type=int,
+                        default=_DEFAULT_THREADS,                   help=f"Download threads (default {_DEFAULT_THREADS})")
+    parser.add_argument("-o", "--output", default=str(DOWNLOAD_DIR), help="Output directory")
+    parser.add_argument("--clear-cache", action="store_true",       help="Clear search cache and exit")
+
+    args = parser.parse_args()
+
+    if args.clear_cache:
+        _cache.clear()
+        console.print("  [green]✓ Cache cleared.[/green]")
+        return
+
+    run(args)
+
+
+if __name__ == "__main__":
+    main()

java2_extention/cache.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+_CACHE_DIR  = Path.home() / ".cache" / "fpv-dl"
+_CACHE_FILE = _CACHE_DIR / "search.json"
+_TTL        = 1800
+
+
+def _load() -> dict:
+    try:
+        if _CACHE_FILE.exists():
+            with open(_CACHE_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {}
+
+
+def _save(data: dict) -> None:
+    try:
+        _CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(_CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    except Exception:
+        pass
+
+
+def get(query: str) -> Optional[list[dict]]:
+    data  = _load()
+    key   = query.strip().lower()
+    entry = data.get(key)
+    if entry and time.time() - entry.get("ts", 0) < _TTL:
+        return entry["results"]
+    return None
+
+
+def put(query: str, results: list[dict]) -> None:
+    data = _load()
+    key  = query.strip().lower()
+    data[key] = {"ts": time.time(), "results": results}
+    _save(data)
+
+
+def clear() -> None:
+    try:
+        if _CACHE_FILE.exists():
+            _CACHE_FILE.unlink()
+    except Exception:
+        pass

java2_extention/config.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+import json
+import platform
+import sys
+from pathlib import Path
+
+_CFG_PATH = Path.home() / ".config" / "java2-extention" / "config.json"
+
+_IS_TERMUX = (
+    platform.machine() in ("aarch64", "armv7l")
+    or platform.system() == "Android"
+    or "com.termux" in sys.executable
+)
+
+
+def _default_download_dir() -> str:
+    if _IS_TERMUX:
+        candidates = [
+            Path("/sdcard/Download"),
+            Path("/storage/emulated/0/Download"),
+        ]
+        for c in candidates:
+            if c.exists():
+                return str(c)
+    return str(Path.home() / "downloads")
+
+
+_DEFAULTS: dict = {
+    "download_dir": _default_download_dir(),
+    "threads": 8,
+}
+
+
+def load() -> dict:
+    try:
+        if _CFG_PATH.exists():
+            with open(_CFG_PATH, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return {**_DEFAULTS, **data}
+    except Exception:
+        pass
+    return dict(_DEFAULTS)
+
+
+def save(cfg: dict) -> None:
+    _CFG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(_CFG_PATH, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, indent=2)
+
+
+def edit_interactive() -> dict:
+    cfg = load()
+    print()
+    print("  ── Config editor ──────────────────────────")
+    print(f"  1. Download directory  →  {cfg['download_dir']}")
+    print(f"  2. Threads             →  {cfg['threads']}")
+    print(f"  3. Save and exit")
+    print()
+
+    while True:
+        raw = input("  Select [1-3]: ").strip()
+        if raw == "3" or raw == "":
+            break
+        if raw == "1":
+            new = input(f"  New download dir [{cfg['download_dir']}]: ").strip()
+            if new:
+                cfg["download_dir"] = str(Path(new).expanduser())
+        elif raw == "2":
+            new = input(f"  Threads [{cfg['threads']}]: ").strip()
+            if new.isdigit():
+                cfg["threads"] = int(new)
+
+    save(cfg)
+    print(f"  ✓ Saved to {_CFG_PATH}")
+    return cfg