pkg-anime-1 1.0.0__tar.gz

pkg_anime_1-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: pkg-anime-1
+Version: 1.0.0
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: cloudscraper>=1.2.60
+Requires-Dist: requests>=2.28.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: urllib3>=2.0.0

pkg_anime_1-1.0.0/README.md

@@ -0,0 +1,126 @@
+# beeg-dl
+
+Python package for browsing and downloading videos from beeg.com.  
+Supports parallel chunked MP4 download and HLS multi-quality (240p / 360p / 480p / 720p / 1080p).  
+Works on Linux, macOS, Windows, and Termux (Android/ARMv7/ARM64).
+
+## Install
+
+```bash
+pip install beeg-dl
+```
+
+## Usage
+
+```bash
+beeg              # interactive menu (browse tags, download)
+beeg "teen"       # browse #teen tag directly
+beeg --recent     # browse amateur (most active tag)
+
+beegdl <url>                  # download by beeg.com URL
+beegdl 967221069944483        # download by numeric file ID
+beegdl <url> -q 720           # download at 720p
+beegdl <url> -o ~/Downloads   # custom output folder
+beegdl <url> -t 8             # 8 download threads
+```
+
+## Python API
+
+```python
+from beeg_dl.scraper import BeegScraper
+from beeg_dl.downloader import download
+from pathlib import Path
+
+scraper = BeegScraper()
+
+# Browse videos by tag (paginated)
+videos = scraper.tag_videos("teen", limit=32, offset=0)
+for v in videos:
+    print(v.file_id, v.title, v.duration_str, v.best_quality)
+
+# Get full details + fresh CDN tokens for a video
+video = scraper.video_detail(967221069944483)
+print(video.title, video.qualities)
+
+# Resolve a beeg.com URL
+video = scraper.from_url("https://beeg.com/967221069944483")
+
+# Get download URL (HLS or direct MP4)
+url, mode = scraper.quality_url(video, quality=1080)
+
+# Download (handles both direct MP4 and HLS automatically)
+def progress(done, total, bps):
+    pct = done / total * 100 if total else 0
+    print(f"\r{pct:.1f}%  {bps/1024/1024:.1f} MB/s", end="", flush=True)
+
+path = download(url, Path("video.mp4"), quality=1080, threads=16, progress=progress)
+print(f"\nSaved to {path}")
+```
+
+## How It Works
+
+### API Architecture
+
+beeg.com is a single-page app (Vue.js) backed by a REST API at  
+`https://store.externulls.com` — no authentication required for reading.
+
+| Endpoint | Description |
+|---|---|
+| `GET /tag/videos/{slug}?limit=N&offset=N` | Paginated video list by tag slug |
+| `GET /facts/file/{file_id}` | Full video details with fresh CDN tokens |
+
+### Video CDN
+
+Videos are served from `https://video.beeg.com/{token}`.  
+Tokens are **time-limited** (~60 s) and include an HMAC key, expiry timestamp,  
+and data segment. Always call `scraper.video_detail(file_id)` immediately before  
+downloading to get a fresh token.
+
+Token types in the API response:
+- `file.resources.fl_cdn_240` → direct MP4 at 240p
+- `file.fallback` → direct MP4 at 480p
+- `file.hls_resources.fl_cdn_multi` → HLS master playlist (all qualities)
+
+### Quality Selection
+
+The HLS master playlist (`fl_cdn_multi`) contains streams for all available  
+qualities: **240p, 360p, 480p, 720p, 1080p**.  
+`beegdl` parses the master, selects the closest stream to your requested quality,  
+downloads all `.ts` segments in parallel, and muxes them with `ffmpeg` (or raw  
+binary concatenation if ffmpeg is not available).
+
+### Thumbnails
+
+`https://thumbs.externulls.com/videos/{file_id}/{thumb_idx}.webp`
+
+### Search
+
+beeg.com uses a WebSocket API (`wss://search.externulls.com`) for search — there  
+is no HTTP search endpoint. Use tag-based browsing as the primary discovery method.
+
+## Configuration
+
+Config file: `~/.config/beeg-dl/config.json`
+
+```json
+{
+  "download_dir":        "~/Downloads",
+  "preferred_quality":  1080,
+  "threads":            16,
+  "page_size":          32,
+  "cache_ttl":          3600
+}
+```
+
+## Popular Tags
+
+`teen`, `amateur`, `milf`, `lesbian`, `anal`, `blowjob`, `hardcore`, `asian`,  
+`ebony`, `latina`, `blonde`, `brunette`, `bbw`, `creampie`, `cumshot`, `pov`,  
+`solo`, `masturbation`, `squirt`, `bdsm`, `interracial`, `big-tits`, `college`,  
+`step-mom`, `step-sister`, `casting`, `massage`, and more.
+
+## Requirements
+
+- Python ≥ 3.10  
+- `cloudscraper`, `rich`, `urllib3` (auto-installed)  
+- `ffmpeg` (optional but recommended for HLS quality selection and muxing)

pkg_anime_1-1.0.0/beeg_dl/__init__.py

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

pkg_anime_1-1.0.0/beeg_dl/__main__.py

@@ -0,0 +1,3 @@
+"""Allow `python -m beeg_dl` to run the CLI."""
+from .cli import beeg_main
+beeg_main()

pkg_anime_1-1.0.0/beeg_dl/cache.py

@@ -0,0 +1,57 @@
+"""
+cache.py
+========
+Simple disk cache for API responses (avoids re-fetching the same video data).
+"""
+from __future__ import annotations
+
+import json
+import hashlib
+import time
+from pathlib import Path
+from typing import Optional, Any
+
+CACHE_DIR = Path.home() / ".cache" / "beeg-dl"
+DEFAULT_TTL = 3600  # 1 hour
+
+
+def _key_to_path(key: str) -> Path:
+    h = hashlib.sha256(key.encode()).hexdigest()[:16]
+    return CACHE_DIR / f"{h}.json"
+
+
+def get(key: str, ttl: int = DEFAULT_TTL) -> Optional[Any]:
+    path = _key_to_path(key)
+    if not path.exists():
+        return None
+    try:
+        raw = json.loads(path.read_text())
+        if time.time() - raw.get("ts", 0) > ttl:
+            path.unlink(missing_ok=True)
+            return None
+        return raw["data"]
+    except Exception:
+        return None
+
+
+def set(key: str, data: Any) -> None:
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    path = _key_to_path(key)
+    try:
+        path.write_text(json.dumps({"ts": time.time(), "data": data}))
+    except Exception:
+        pass
+
+
+def clear() -> int:
+    """Delete all cached files. Returns count deleted."""
+    if not CACHE_DIR.exists():
+        return 0
+    count = 0
+    for f in CACHE_DIR.glob("*.json"):
+        try:
+            f.unlink()
+            count += 1
+        except Exception:
+            pass
+    return count

pkg_anime_1-1.0.0/beeg_dl/cli.py

@@ -0,0 +1,444 @@
+"""
+cli.py
+======
+Rich interactive CLI for beeg-dl.
+
+Entry points:
+  beeg              — interactive browse + download menu
+  beeg "teen"       — browse tag directly
+  beegdl <url>      — download any beeg.com video URL or file_id
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+from typing import List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn, DownloadColumn, Progress, SpinnerColumn,
+    TextColumn, TimeRemainingColumn, TransferSpeedColumn,
+)
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+from rich import print as rprint
+
+from . import config as _cfg
+from .models import VideoEntry
+from .scraper import BeegScraper, POPULAR_TAGS
+from .downloader import download
+
+console = Console()
+
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def _make_progress() -> Progress:
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}"),
+        BarColumn(bar_width=40),
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    )
+
+
+def _fmt_dur(seconds: int) -> str:
+    m, s = divmod(seconds, 60)
+    h, m = divmod(m, 60)
+    if h:
+        return f"{h}h {m:02d}m"
+    return f"{m}m {s:02d}s"
+
+
+def _fmt_size(n: int) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+def _show_video_list(videos: List[VideoEntry], tag: str, page: int) -> None:
+    table = Table(title=f"[bold]#{tag}[/bold] — page {page}", show_lines=False,
+                  border_style="dim", expand=True)
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Title", no_wrap=False)
+    table.add_column("Duration", justify="right", width=8)
+    table.add_column("Resolution", justify="right", width=11)
+    table.add_column("Quality", justify="right", width=8)
+
+    for i, v in enumerate(videos, 1):
+        best_q = f"{v.best_quality}p" if v.best_quality else "?"
+        res    = f"{v.width}×{v.height}" if v.width else "?"
+        dur    = _fmt_dur(v.duration) if v.duration else "?"
+        table.add_row(str(i), v.title, dur, res, best_q)
+
+    console.print(table)
+
+
+def _pick_quality(video: VideoEntry) -> int:
+    cfg = _cfg.load()
+    preferred = cfg.get("preferred_quality", 1080)
+    available = sorted({q.quality for q in video.qualities}, reverse=True)
+    if not available:
+        return preferred
+    # Return highest available up to preferred
+    for q in available:
+        if q <= preferred:
+            return q
+    return available[-1]
+
+
+def _do_download(video: VideoEntry, scraper: BeegScraper, cfg: dict) -> None:
+    # Always re-fetch detail so tokens are fresh
+    console.print(f"[dim]Refreshing CDN tokens for video {video.file_id}…[/dim]")
+    fresh = scraper.video_detail(video.file_id)
+    if not fresh:
+        console.print("[red]Could not fetch video details.[/red]")
+        return
+
+    quality = _pick_quality(fresh)
+    url, mode = scraper.quality_url(fresh, quality)
+    if not url:
+        console.print("[red]No downloadable URL found.[/red]")
+        return
+
+    # Show confirm
+    sizes = {q.quality: q.size for q in fresh.qualities}
+    size  = sizes.get(quality, 0)
+    console.print(Panel(
+        f"[bold]{fresh.title}[/bold]\n"
+        f"Quality: [green]{quality}p[/green]  "
+        f"Mode: [cyan]{mode.upper()}[/cyan]  "
+        f"Estimated size: [yellow]{_fmt_size(size) if size else 'unknown'}[/yellow]\n"
+        f"Duration: {_fmt_dur(fresh.duration)}\n"
+        f"URL: [dim]{url[:80]}…[/dim]",
+        title="Ready to download"
+    ))
+
+    safe_title = "".join(c if c.isalnum() or c in " _-" else "_" for c in fresh.title)[:80]
+    ext        = "mp4"
+    filename   = f"{fresh.file_id}_{safe_title}.{ext}"
+    out_dir    = Path(cfg.get("download_dir", str(Path.home() / "Downloads")))
+    out_path   = out_dir / filename
+
+    if not Confirm.ask(f"Download to [bold]{out_path}[/bold]?", default=True):
+        return
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    threads = cfg.get("threads", 16)
+
+    task_id = None
+    progress_obj = _make_progress()
+    done_ref   = [0]
+    total_ref  = [0]
+    speed_ref  = [0.0]
+    start_time = time.time()
+
+    def _on_progress(done: int, total: int, bps: float) -> None:
+        done_ref[0]  = done
+        total_ref[0] = total
+        speed_ref[0] = bps
+        if task_id is not None:
+            progress_obj.update(task_id, completed=done,
+                                total=total if total else None)
+
+    import threading
+
+    def _run() -> None:
+        nonlocal task_id
+        with progress_obj:
+            task_id = progress_obj.add_task(
+                f"Downloading {quality}p…",
+                total=size if size else None,
+            )
+            try:
+                download(url, out_path, quality=quality,
+                         threads=threads, progress=_on_progress, mode=mode)
+            except Exception as e:
+                console.print(f"[red]Download failed: {e}[/red]")
+
+    t = threading.Thread(target=_run)
+    t.start()
+    t.join()
+
+    if out_path.exists():
+        elapsed = time.time() - start_time
+        size_dl = out_path.stat().st_size
+        console.print(
+            f"[green]✓ Saved:[/green] {out_path}\n"
+            f"  Size: {_fmt_size(size_dl)}  Time: {elapsed:.0f}s"
+        )
+    else:
+        console.print("[red]Output file not found — download may have failed.[/red]")
+
+
+# ── browse flow ───────────────────────────────────────────────────────────────
+
+def _browse_tag(tag: str, scraper: BeegScraper, cfg: dict) -> None:
+    page     = 1
+    per_page = cfg.get("page_size", 32)
+
+    while True:
+        offset = (page - 1) * per_page
+        with console.status(f"[dim]Loading #{tag} page {page}…[/dim]"):
+            videos = scraper.tag_videos(tag, limit=per_page, offset=offset)
+
+        if not videos:
+            console.print(f"[yellow]No videos found for #{tag} (page {page}).[/yellow]")
+            if page > 1:
+                page -= 1
+                continue
+            return
+
+        _show_video_list(videos, tag, page)
+
+        choices = [str(i) for i in range(1, len(videos) + 1)]
+        console.print(
+            "[dim]Enter a number to download  |  [bold]n[/bold] = next page  "
+            "|  [bold]p[/bold] = prev page  |  [bold]q[/bold] = back[/dim]"
+        )
+        choice = Prompt.ask("Choice", default="q").strip().lower()
+
+        if choice == "q":
+            return
+        elif choice == "n":
+            page += 1
+        elif choice == "p" and page > 1:
+            page -= 1
+        elif choice in choices:
+            video = videos[int(choice) - 1]
+            _do_download(video, scraper, cfg)
+        else:
+            console.print("[red]Invalid choice.[/red]")
+
+
+# ── main menus ────────────────────────────────────────────────────────────────
+
+def _tag_menu(scraper: BeegScraper, cfg: dict) -> None:
+    console.print(Panel(
+        "\n".join(
+            "  ".join(f"[cyan]{t}[/cyan]" for t in POPULAR_TAGS[i:i+5])
+            for i in range(0, len(POPULAR_TAGS), 5)
+        ),
+        title="Popular Tags",
+    ))
+    tag = Prompt.ask("Enter a tag slug", default="teen").strip().lower()
+    if tag:
+        _browse_tag(tag, scraper, cfg)
+
+
+def _url_menu(scraper: BeegScraper, cfg: dict) -> None:
+    url = Prompt.ask("Paste beeg.com URL or file_id").strip()
+    if not url:
+        return
+    with console.status("[dim]Resolving…[/dim]"):
+        video = scraper.from_url(url)
+    if not video:
+        console.print("[red]Could not resolve video.[/red]")
+        return
+    console.print(Panel(
+        f"[bold]{video.title}[/bold]\n"
+        f"Duration: {_fmt_dur(video.duration)}   "
+        f"Resolution: {video.resolution_str}   "
+        f"Best quality: {video.best_quality}p",
+        title=f"Video {video.file_id}"
+    ))
+    _do_download(video, scraper, cfg)
+
+
+def interactive_menu() -> None:
+    cfg     = _cfg.load()
+    scraper = BeegScraper(cache_ttl=cfg.get("cache_ttl", 3600))
+
+    console.print(Panel(
+        "[bold cyan]beeg-dl[/bold cyan]  —  beeg.com downloader\n"
+        "[dim]Browse by tag or paste a URL to download.[/dim]",
+        border_style="cyan"
+    ))
+
+    while True:
+        console.print(
+            "\n  [bold]1[/bold] Browse by tag\n"
+            "  [bold]2[/bold] Download from URL / file ID\n"
+            "  [bold]3[/bold] Clear cache\n"
+            "  [bold]q[/bold] Quit\n"
+        )
+        choice = Prompt.ask("Menu", default="q").strip().lower()
+
+        if choice == "1":
+            _tag_menu(scraper, cfg)
+        elif choice == "2":
+            _url_menu(scraper, cfg)
+        elif choice == "3":
+            from . import cache as _c
+            n = _c.clear()
+            console.print(f"[green]Cleared {n} cached items.[/green]")
+        elif choice in ("q", "quit", "exit"):
+            console.print("[dim]Bye.[/dim]")
+            return
+        else:
+            console.print("[red]Invalid choice.[/red]")
+
+
+# ── beeg command ──────────────────────────────────────────────────────────────
+
+def beeg_main() -> None:
+    """
+    Entry point for the `beeg` command.
+
+    Usage
+    -----
+      beeg                 → interactive browse/download menu
+      beeg <tag>           → browse that tag directly (e.g. beeg milf)
+      beeg <url>           → resolve & download a beeg.com URL
+      beeg <file_id>       → resolve & download by numeric file ID
+      beeg -r / --recent   → browse the #amateur tag
+      beeg -V / --version  → print version
+      beeg -h / --help     → show this help
+    """
+    import argparse
+    from . import __version__
+
+    parser = argparse.ArgumentParser(
+        prog="beeg",
+        description=(
+            "beeg.com interactive downloader.\n\n"
+            "With no arguments: opens the interactive browse/download menu.\n"
+            "With a tag slug (e.g. 'teen', 'milf'): browse that tag.\n"
+            "With a URL or numeric file ID: download that video directly."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "target",
+        nargs="?",
+        default=None,
+        metavar="TAG|URL|ID",
+        help="Tag slug, beeg.com URL, or numeric file ID (omit for interactive menu).",
+    )
+    parser.add_argument(
+        "-r", "--recent",
+        action="store_true",
+        help="Browse the #amateur tag (most active).",
+    )
+    parser.add_argument(
+        "-q", "--quality",
+        type=int,
+        default=None,
+        choices=[240, 360, 480, 720, 1080],
+        help="Preferred quality when downloading directly (default: 1080).",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        default=None,
+        metavar="DIR",
+        help="Output directory (default: from config, usually ~/Downloads).",
+    )
+    parser.add_argument(
+        "-V", "--version",
+        action="version",
+        version=f"beeg-dl {__version__}",
+    )
+
+    args = parser.parse_args()
+
+    cfg     = _cfg.load()
+    if args.quality:
+        cfg["preferred_quality"] = args.quality
+    if args.output:
+        cfg["download_dir"] = args.output
+
+    scraper = BeegScraper(cache_ttl=cfg.get("cache_ttl", 3600))
+
+    # ── routing ───────────────────────────────────────────────────────────────
+    if args.recent:
+        _browse_tag("amateur", scraper, cfg)
+        return
+
+    if args.target is None:
+        # No arguments → full interactive menu
+        interactive_menu()
+        return
+
+    target = args.target.strip()
+
+    # URL or numeric file ID → resolve and download
+    if target.startswith("http") or target.isdigit():
+        with console.status("[dim]Resolving…[/dim]"):
+            video = scraper.from_url(target)
+        if not video:
+            console.print("[red]Could not resolve video. Check the URL or file ID.[/red]")
+            sys.exit(1)
+        console.print(Panel(
+            f"[bold]{video.title}[/bold]\n"
+            f"Duration: {_fmt_dur(video.duration)}   "
+            f"Resolution: {video.resolution_str}   "
+            f"Best quality: {video.best_quality}p",
+            title=f"Video {video.file_id}"
+        ))
+        _do_download(video, scraper, cfg)
+        return
+
+    # Otherwise treat as a tag slug
+    _browse_tag(target, scraper, cfg)
+
+
+# ── beegdl command ────────────────────────────────────────────────────────────
+
+def beegdl_main() -> None:
+    """
+    Entry point for the `beegdl` command.
+
+    Usage:
+      beegdl <url_or_file_id>            download video
+      beegdl <url_or_file_id> -q 720     download at 720p
+      beegdl <url_or_file_id> -o /path   custom output directory
+    """
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="beegdl",
+        description="Download a beeg.com video by URL or file ID.",
+    )
+    parser.add_argument("target", help="beeg.com video URL or numeric file ID")
+    parser.add_argument("-q", "--quality", type=int, default=None,
+                        choices=[240, 360, 480, 720, 1080],
+                        help="Preferred quality (default: from config)")
+    parser.add_argument("-o", "--output", default=None,
+                        help="Output directory (default: from config)")
+    parser.add_argument("-t", "--threads", type=int, default=None,
+                        help="Download threads (default: from config)")
+    args = parser.parse_args()
+
+    cfg     = _cfg.load()
+    scraper = BeegScraper(cache_ttl=cfg.get("cache_ttl", 3600))
+
+    if args.quality:
+        cfg["preferred_quality"] = args.quality
+    if args.output:
+        cfg["download_dir"] = args.output
+    if args.threads:
+        cfg["threads"] = args.threads
+
+    with console.status("[dim]Resolving video…[/dim]"):
+        video = scraper.from_url(args.target)
+
+    if not video:
+        console.print("[red]Could not resolve video. Check the URL or file ID.[/red]")
+        sys.exit(1)
+
+    console.print(Panel(
+        f"[bold]{video.title}[/bold]\n"
+        f"Duration: {_fmt_dur(video.duration)}   "
+        f"Resolution: {video.resolution_str}",
+        title=f"Video {video.file_id}"
+    ))
+
+    _do_download(video, scraper, cfg)

pkg_anime_1-1.0.0/beeg_dl/config.py

@@ -0,0 +1,43 @@
+"""
+config.py
+=========
+User-configurable settings for beeg-dl.
+"""
+from __future__ import annotations
+
+import json
+import platform
+import sys
+from pathlib import Path
+from typing import Optional
+
+CONFIG_PATH = Path.home() / ".config" / "beeg-dl" / "config.json"
+
+_IS_TERMUX = (
+    platform.machine() in ("aarch64", "armv7l")
+    or platform.system() == "Android"
+    or "com.termux" in sys.executable
+)
+
+DEFAULTS = {
+    "download_dir": str(Path.home() / ("Downloads" if not _IS_TERMUX else "storage/downloads")),
+    "preferred_quality": 1080,   # 240, 360, 480, 720, 1080 — falls back if unavailable
+    "threads": 4 if _IS_TERMUX else 16,
+    "page_size": 32,
+    "cache_ttl": 3600,
+}
+
+
+def load() -> dict:
+    cfg = dict(DEFAULTS)
+    if CONFIG_PATH.exists():
+        try:
+            cfg.update(json.loads(CONFIG_PATH.read_text()))
+        except Exception:
+            pass
+    return cfg
+
+
+def save(cfg: dict) -> None:
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(cfg, indent=2))