indonime 1.0.0__py3-none-any.whl

indonime/__init__.py

@@ -0,0 +1,369 @@
+"""Indonime TUI — search → select → play loop."""
+import argparse
+import importlib
+import os
+import pkgutil
+import time
+
+from . import player
+from .ui import (
+    console, print_banner, print_header, print_step,
+    print_success, print_error, print_warning, print_info, print_separator,
+    make_episode_table, make_postplay_actions, make_footer,
+    make_progress_bar, styled_status, make_style, Palette,
+)
+
+from . import plugins
+import requests
+from InquirerPy import inquirer
+from .ext import pdrain, megaNZ
+
+_SESSION = requests.Session()
+
+
+def _play_episode(episode_url, plugin, custom_style):
+    """Resolve stream and play. Returns True if played successfully."""
+    with console.status(styled_status("🔍 Resolving stream...")):
+        dl_links = plugin.downloads(episode_url)
+
+    options = []
+    opt_map = {}
+    for res, servers in dl_links.items():
+        for s_name, s_url in servers.items():
+            if any(x in s_name.lower() for x in ['pdrain', 'pixeldrain', 'mega']):
+                label = f'[{res}] {s_name}'
+                options.append({'name': label, 'value': s_url})
+                opt_map[s_url] = label
+
+    if not options:
+        print_warning("No compatible servers found.")
+        return False
+
+    selected_opt = inquirer.select(
+        message='📥  Select quality & server:',
+        choices=options,
+        style=custom_style,
+    ).execute()
+    if not selected_opt:
+        return False
+    server_url = selected_opt
+    last_selected_server_name = opt_map[server_url]
+
+    final_target = None
+    is_temp = False
+
+    # ── Indeterminate pulse bar while resolving ──
+    if 'mega' in last_selected_server_name.lower():
+        final_mega_url = None
+        with make_progress_bar() as progress:
+            task = progress.add_task(
+                f"[{Palette.primary}]🔓 Resolving Mega link...",
+                total=None,
+            )
+
+            try:
+                resp = _SESSION.get(server_url, allow_redirects=True, timeout=15)
+                curr = resp.url
+                if "mega.nz" in curr and ("#" in curr or "#!" in curr):
+                    final_mega_url = curr
+                else:
+                    print_error("Redirect tidak mengarah ke Mega.")
+                    return False
+            except Exception as e:
+                print_error(f"Requests Error: {e}")
+                time.sleep(3)
+                return False
+
+            if not final_mega_url:
+                print_error("Timeout: Gagal mendapatkan link Mega.")
+                return False
+
+            if "#!" in final_mega_url:
+                final_mega_url = final_mega_url.replace("#!", "file/").replace("!", "#", 1)
+
+            progress.update(task,
+                description=f"[{Palette.highlight}]📥 Buffering stream...")
+
+            # ponytail: sequential streaming (resolve_mega_file_stream) over parallel Range requests.
+            # parallel approach fails on some MEGA CDNs that don't support Range or silently drop
+            # connections. Streaming is one GET, no Range, more compatible.
+            try:
+                f_id = final_mega_url.split("file/")[1].split("#")[0]
+                stream = megaNZ.resolve_mega_file_stream(final_mega_url, f_id, console)
+                if stream is None:
+                    return False
+                path, ready, stop, dl_thread = stream
+
+                _stall_t0 = time.time()
+                while not ready.is_set():
+                    if time.time() - _stall_t0 > 60:
+                        print_warning("Buffering timed out (>60s). Check connection or retry.")
+                        return False
+                    time.sleep(0.15)
+            except Exception as e:
+                print_error(f"Gagal Streaming: {e}")
+                time.sleep(3)
+                return False
+
+        # Buffering complete -> launch mpv
+        print_step("🚀 Launching mpv player...")
+        player.play_with_mpv(path, is_temp_file=True, cleanup=False)
+        stop.set()
+        dl_thread.join(timeout=10)
+        if os.path.exists(path):
+            os.remove(path)
+        return True
+
+    else:
+        # PixelDrain path (indeterminate pulse bar)
+        with make_progress_bar() as progress:
+            task = progress.add_task(
+                f"[{Palette.secondary}]🌀 Bypassing PixelDrain link...",
+                total=None,
+            )
+            import threading as _th
+            result_holder = [None]
+            def _do_scrape():
+                result_holder[0] = pdrain.scrape(server_url)
+            scrape_thread = _th.Thread(target=_do_scrape, daemon=True)
+            scrape_thread.start()
+            while scrape_thread.is_alive():
+                time.sleep(0.1)
+            final_target = result_holder[0]
+
+        if final_target:
+            print_step("🚀 Launching mpv player...")
+            return player.play_with_mpv(final_target, is_temp_file=is_temp)
+        else:
+            print_error("Stream resolution failed.")
+            return False
+
+
+def _episode_nav(episode_list, plugin, custom_style, back_label='<< BACK', show_banner=True):
+    """Episode pick → play → post-play loop. Returns 'back' or 'quit'."""
+    idx = 0
+    while True:
+        if show_banner:
+            print_banner()
+        print_header("📋 EPISODES", "🎬")
+        console.print(make_episode_table(episode_list))
+        print_separator()
+
+        ep_choices = [
+            {'name': f'  EP{i+1:02d}  —  {ep["title"][:50]}', 'value': i}
+            for i, ep in enumerate(episode_list)
+        ]
+        ep_choices.append({'name': f'  ↩  {back_label}', 'value': 'back'})
+
+        selected = inquirer.select(
+            message='▶  Select episode:',
+            choices=ep_choices,
+            default=idx,
+            style=custom_style,
+            qmark="",
+        ).execute()
+
+        if selected == 'back' or selected is None:
+            from .plugins._base import cache_clear
+            cache_clear()
+            return 'back'
+        idx = selected
+
+        # ponytail: inner loop keeps QUALITY/REPLAY on same episode instead of reopening episode list
+        while True:
+            print_header("🎬 NOW PLAYING", "▶")
+            if not _play_episode(episode_list[idx]['url'], plugin, custom_style):
+                time.sleep(2)
+                break
+
+            print_separator()
+
+            post_choices = make_postplay_actions(idx, len(episode_list))
+            cmd = inquirer.select(
+                message="🎮  Command:",
+                choices=post_choices,
+                style=custom_style,
+                qmark="",
+            ).execute()
+
+            if cmd == '▶  NEXT':
+                if idx + 1 < len(episode_list):
+                    idx += 1
+                    continue
+                break
+            elif cmd == '◀  PREV':
+                if idx > 0:
+                    idx -= 1
+                    continue
+                break
+            elif cmd in ('↺  REPLAY', '⚙  QUALITY'):
+                continue  # replay same episode / choose different quality
+            else:
+                return 'quit'
+
+
+def _tui_loop():
+    p_name = 'otakudesu'
+    _last_plugin_name = None
+    _plugin = None
+    custom_style = make_style()
+    available_providers = [
+        m.name for m in pkgutil.iter_modules(plugins.__path__)
+        if not m.name.startswith('_')
+    ]
+
+    while True:
+        print_banner()
+
+        if p_name != _last_plugin_name:
+            _plugin = importlib.import_module(f'indonime.plugins.{p_name}')
+            _last_plugin_name = p_name
+
+        is_switching = False
+        try:
+            prompt = inquirer.text(
+                message='🔍  Search anime:',
+                qmark='',
+                instruction='[alt+p] switch provider',
+                style=custom_style,
+                validate=lambda x: True if is_switching else len(x) > 0,
+            )
+            @prompt.register_kb('alt-p')
+            def _(event):
+                nonlocal is_switching
+                is_switching = True
+                event.app.exit(result='/switch')
+            result = prompt.execute()
+        except KeyboardInterrupt:
+            break
+
+        if result == '/switch':
+            new_p = inquirer.select(
+                message='📡  Select provider:',
+                choices=available_providers,
+                qmark='',
+                style=custom_style,
+            ).execute()
+            if new_p:
+                p_name = new_p
+            continue
+        if not result:
+            break
+
+        print_header("🔎 SEARCHING", "🔎")
+        with console.status(styled_status(f'Searching for "{result}"...')):
+            results = _plugin.search_anime(result)
+
+        if not results:
+            print_warning("No results found.")
+            time.sleep(2)
+            continue
+
+        choices = [item['title'] for item in results] + ['-- ABORT --']
+        selected_title = inquirer.fuzzy(
+            message='📺  Select title:',
+            choices=choices,
+            style=custom_style,
+        ).execute()
+
+        if selected_title == '-- ABORT --' or not selected_title:
+            continue
+
+        selected_url = next(
+            item['url'] for item in results
+            if item['title'] == selected_title
+        )
+
+        print_header("📋 EPISODES", "🎬")
+        with console.status(styled_status("Fetching episode list...")):
+            episode_list = _plugin.episodes(selected_url)
+
+        if not episode_list:
+            print_warning("No episodes found.")
+            time.sleep(2)
+            continue
+
+        if _episode_nav(
+            episode_list, _plugin, custom_style,
+            back_label='<< BACK TO SEARCH', show_banner=True
+        ) == 'quit':
+            break
+
+    print_banner()
+    make_footer()
+    print_success("Thanks for using Indonime! ~ Sayonara ~")
+
+def _search_mode(query, provider='otakudesu'):
+    """One-shot search → play → exit."""
+    custom_style = make_style()
+    print_banner()
+
+    try:
+        plugin = importlib.import_module(f'indonime.plugins.{provider}')
+    except Exception as e:
+        print_error(f"Plugin error: {e}")
+        input('[Press Enter]')
+        return
+
+    print_header("🔎 SEARCHING", "🔎")
+    with console.status(styled_status(f'Searching for "{query}"...')):
+        results = plugin.search_anime(query)
+
+    if not results:
+        print_warning("No results found.")
+        input('[Press Enter]')
+        return
+
+    choices = [item['title'] for item in results] + ['-- ABORT --']
+    selected_title = inquirer.fuzzy(
+        message='📺  Select title:',
+        choices=choices,
+        style=custom_style,
+    ).execute()
+
+    if selected_title == '-- ABORT --' or not selected_title:
+        return
+
+    selected_url = next(
+        item['url'] for item in results
+        if item['title'] == selected_title
+    )
+
+    print_header("📋 EPISODES", "🎬")
+    with console.status(styled_status("Fetching episode list...")):
+        episode_list = plugin.episodes(selected_url)
+
+    if not episode_list:
+        print_warning("No episodes found.")
+        input('[Press Enter]')
+        return
+
+    _episode_nav(
+        episode_list, plugin, custom_style,
+        back_label='<< QUIT', show_banner=False
+    )
+
+    if player.current_mpv_process and player.current_mpv_process.poll() is None:
+        player.current_mpv_process.wait()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Indonime — Subtitle Indonesia Anime Searcher'
+    )
+    parser.add_argument(
+        'mode', nargs='?', default='tui',
+        help='Mode: tui (interactive, default) or search <query>'
+    )
+    parser.add_argument('query', nargs='*', help='Search query')
+    parser.add_argument(
+        '-p', '--provider', default='otakudesu',
+        choices=['otakudesu', 'anoboy'],
+        help='Provider (default: otakudesu)'
+    )
+    args = parser.parse_args()
+
+    if args.mode == 'search' and args.query:
+        _search_mode(' '.join(args.query), args.provider)
+    else:
+        _tui_loop()

indonime/__main__.py

@@ -0,0 +1,7 @@
+from indonime import main
+
+try:
+  main()
+except KeyboardInterrupt:
+  from rich.console import Console
+  Console().print(f'\n[yellow]Sayonara![/yellow]')

indonime/_mpv_install.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Cross-platform mpv installer for Indonime."""
+import os
+import sys
+import shutil
+import platform
+import subprocess
+import urllib.request
+from pathlib import Path
+from rich.console import Console
+from rich.progress import (
+    Progress, BarColumn, DownloadColumn,
+    TransferSpeedColumn, TimeRemainingColumn,
+)
+
+console = Console()
+
+BASE = Path(__file__).resolve().parent.parent  # project root (indonime/)
+MPV_DIR = BASE / "mpv"
+
+
+def _download(url, dest, desc="Downloading"):
+  dest = Path(dest)
+  try:
+    resp = urllib.request.urlopen(url)
+    total = int(resp.headers.get("content-length", 0))
+    with Progress(
+        "[progress.description]{task.description}", BarColumn(),
+        DownloadColumn(), TransferSpeedColumn(), TimeRemainingColumn(),
+        console=console,
+    ) as p:
+      task = p.add_task(f"[cyan]{desc}", total=total)
+      with open(dest, "wb") as f:
+        for chunk in iter(lambda: resp.read(64 * 1024), b""):
+          f.write(chunk)
+          p.update(task, advance=len(chunk))
+    return True
+  except Exception as e:
+    console.print(f"[red]✘ Download failed: {e}[/red]")
+    return False
+
+
+def _install_windows():
+  """Download mpv.7z, extract via 7zr.exe (standalone)."""
+  mpv_url = "https://github.com/salsa-ram/indonime/releases/download/v1.0.0-mpv/mpv.7z"
+  mpv_7z = BASE / "mpv.7z"
+
+  if not _download(mpv_url, mpv_7z, "Downloading MPV"):
+    return False
+
+  console.print("[cyan]Extracting...[/cyan]")
+  MPV_DIR.mkdir(exist_ok=True)
+
+  for exe, args in [
+      (r"C:\Program Files\7-Zip\7z.exe", [r"C:\Program Files\7-Zip\7z.exe", "x", str(mpv_7z), f"-o{MPV_DIR}", "-y"]),
+      (r"C:\Program Files\WinRAR\WinRAR.exe", [r"C:\Program Files\WinRAR\WinRAR.exe", "x", str(mpv_7z), f"{MPV_DIR}\\"]),
+  ]:
+    if os.path.exists(exe):
+      subprocess.run(args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+      if (MPV_DIR / "mpv.exe").exists():
+        break
+  else:
+    console.print("[cyan]Downloading 7-Zip standalone extractor...[/cyan]")
+    if not _download("https://www.7-zip.org/a/7zr.exe", BASE / "7zr.exe"):
+      return False
+    subprocess.run([str(BASE / "7zr.exe"), "x", str(mpv_7z), f"-o{MPV_DIR}", "-y"],
+                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    (BASE / "7zr.exe").unlink(missing_ok=True)  # ponytail: BCJ2 archive, needs 7z
+
+  mpv_7z.unlink(missing_ok=True)
+  ok = (MPV_DIR / "mpv.exe").exists()
+  console.print("[green]✓ mpv installed[/green]" if ok else "[red]✘ Extraction failed[/red]")
+  return ok
+
+
+def _install_macos():
+  if shutil.which("brew"):
+    console.print("[cyan]Installing mpv via Homebrew...[/cyan]")
+    r = subprocess.run(["brew", "install", "mpv"], capture_output=True, text=True)
+    if r.returncode == 0:
+      console.print("[green]✓ mpv installed via Homebrew[/green]")
+      return True
+    console.print(f"[yellow]⚠ Homebrew failed: {r.stderr.strip()}[/yellow]")
+  console.print("[yellow]Install manually: brew install mpv[/yellow]")
+  return False
+
+
+def _install_linux():
+  for pm, cmd in [
+      ("apt", ["apt", "install", "-y", "mpv"]),
+      ("pacman", ["pacman", "-S", "--noconfirm", "mpv"]),
+      ("dnf", ["dnf", "install", "-y", "mpv"]),
+      ("zypper", ["zypper", "install", "-y", "mpv"]),
+  ]:
+    if shutil.which(pm):
+      console.print(f"[cyan]Installing mpv via {pm}...[/cyan]")
+      r = subprocess.run(cmd, capture_output=True, text=True)
+      if r.returncode == 0:
+        console.print(f"[green]✓ mpv installed via {pm}[/green]")
+        return True
+      console.print(f"[yellow]⚠ {pm} failed[/yellow]")
+  console.print("[yellow]Install manually: apt install mpv[/yellow]")
+  return False
+
+
+def main():
+  console.print("[bold cyan]📺 Indonime - MPV Setup[/bold cyan]\n")
+
+  if shutil.which("mpv"):
+    console.print("[green]✓ mpv already in PATH[/green]")
+    return
+
+  system = platform.system()
+  console.print(f"[dim]OS: {system}[/dim]")
+
+  ok = {
+      "Windows": _install_windows,
+      "Darwin": _install_macos,
+  }.get(system, _install_linux)()
+
+  if not ok:
+    console.print("\n[yellow]Install mpv manually:[/yellow]")
+    console.print("  Windows: https://mpv.io/installation/")
+    console.print("  macOS:   brew install mpv")
+    console.print("  Linux:   apt install mpv")
+    sys.exit(1)
+
+  console.print("[bold green]✓ Setup complete![/bold green]")
+
+
+if __name__ == "__main__":
+  main()