riff-player 2.0.0__py3-none-any.whl

riff/__init__.py

@@ -0,0 +1,8 @@
+"""
+Riff - Terminal Media Player
+Play music and video from your terminal. Local or internet.
+"""
+
+__version__ = "2.0.0"
+__author__ = "Sapnoneel Barik"
+__license__ = "MIT"

riff/cache.py

@@ -0,0 +1,236 @@
+"""
+riff/cache.py
+Offline cache - downloads media as compressed .opus files.
+Enforces user-defined size limit with LRU eviction.
+Index stored at ~/.riff/cache_index.json
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+
+from riff.config import (
+    get_cache_dir,
+    get_cache_limit_mb,
+    get_cache_mode,
+    CACHE_INDEX,
+)
+from riff.utils import find_ytdlp, find_mpv
+
+#--- Index helpers -----------------------------------------------------------------------------------------
+def _load_index() -> dict:
+    if os.path.exists(CACHE_INDEX):
+        try:
+            with open(CACHE_INDEX, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return {}
+
+def _save_index(index: dict) -> None:
+    with open(CACHE_INDEX, "w", encoding="utf-8") as f:
+        json.dump(index, f, indent=2)
+
+def _safe_key(text: str) -> str:
+    """Convert title/URL to a safe filename key."""
+    import re
+    return re.sub(r'[^\w\-]', '_', text)[:80]
+
+#--- Core API -----------------------------------------------------------------------------------------------------
+def save_offline(query: str, title: str | None = None) -> str | None:
+    """
+    Downloads a track/URL as .opus and store in cache.
+    Returns the local file path on success, None on failure.
+    """
+    ytdlp = find_ytdlp()
+    if not ytdlp:
+        print("✕ yt-dlp not found.")
+        return None
+    
+    cache_dir = get_cache_dir()
+    os.makedirs(cache_dir, exist_ok=True)
+
+    key     = _safe_key(title or query)
+    outpath = os.path.join(cache_dir, f"{key}.opus")
+
+    #Already cached?
+    if os.path.exists(outpath):
+        print(f"    ✓ Already cached: {os.path.basename(outpath)}")
+        _touch(key)
+        return outpath
+    
+    #Enforce size limit before downloading
+    _evict_if_needed()
+
+    print(f"    ↓ Downloading offline copy: {title or query}")
+
+    import subprocess
+    source = query if query.startswith(("http://", "https://")) else f"ytsearch1:{query}"
+
+    result = subprocess.run(
+        [
+            ytdlp,
+            "--format", "bestaudio/best",
+            "--extract-audio",
+            "--audio-format", "opus",
+            "--audio-quality", "128K",
+            "--output", outpath.replace(".opus", ".%(ext)s"),
+            "--no-playlist",
+            "--quiet",
+            "--no-warnings",
+            source,
+        ],
+        capture_output=True,
+    )
+
+    #yt-dlp may produce .opus or .webm; find what it made
+    actual = _find_output(cache_dir, key)
+    if actual and os.path.exists(actual):
+        index = _load_index()
+        index[key] = {
+            "path":        actual,
+            "title":       title or query,
+            "query":       query,
+            "cached_at":   time.time(),
+            "last_played": time.time(),
+            "play_count":  0,
+            "size_mb":     round(os.path.getsize(actual) / (1024 * 1024), 2),
+        }
+        _save_index(index)
+        print(f"    ✓ Saved: {os.path.basename(actual)}")
+        return actual
+    
+    print(f"    ✕ Failed to cache: {title or query}")
+    return None
+
+def get_cached(query: str) -> str | None:
+    """
+    Check if a query/title is already in the cache.
+    Returns the file path if found, else None.
+    """
+    key   = _safe_key(query)
+    index = _load_index()
+    if key in index:
+        path = index[key]["path"]
+        if os.path.exists(path):
+            _touch(key)
+            return path
+        else:
+            #File missing - remove from index
+            del index[key]
+            _save_index(index)
+    return None
+
+def play_cached(path: str) -> int:
+    """Play a cached file via mpv."""
+    from riff.player import play
+    return play(path)
+
+def list_cache() -> list[dict]:
+    """Return all cachedd tracks sorted by last played (most recent first)."""
+    index  = _load_index()
+    tracks = []
+    for key, meta in index.items():
+        if os.path.exists(meta.get("path", "")):
+            tracks.append(meta)
+    return sorted(tracks, key=lambda x: x.get("last_played", 0), reverse=True)
+
+def clear_cache(key: str | None = None) -> None:
+    """Clear one track (by title) or the entire cache."""
+    index = _load_index()
+
+    if key is None:
+        #Clear all
+        for meta in index.values():
+            _remove_file(meta.get("path"))
+        _save_index({})
+        print(" ✓ Cache cleared.")
+        return
+    
+    safe = _safe_key(key)
+    if safe in index:
+        _remove_file(index[safe].get("path"))
+        del index[safe]
+        _save_index(index)
+        print(f"    ✓ Removed: {key}")
+    else:
+        print(f"    ✕ Not found in cache: {key}")
+
+def cache_size_mb() -> float:
+    """Return total cache size in MB."""
+    index = _load_index()
+    total = 0.0
+    for meta in index.values():
+        p = meta.get("path", "")
+        if os.path.exists(p):
+            total += os.path.getsize(p)
+    return round(total / (1024 * 1024), 2)
+
+#--- Smart cache prompt --------------------------------------------------------------------------------------------
+def maybe_cache(query: str, title: str | None = None) -> None:
+    """
+    Called after a stream.
+    Depending on cache-mode, either silently caches, asks the user, or does nothing.
+    """
+    mode = get_cache_mode()
+
+    if mode == "always":
+        save_offline(query, title)
+
+    elif mode == "ask":
+        try:
+            ans = input("\n 💾 Save this track for offline listening? [y/N]: ").strip().lower()
+            if ans in ("y", "yes"):
+                save_offline(query, title)
+        except (KeyboardInterrupt, EOFError):
+            pass
+        
+    elif mode == "smart":
+        #Cache if this query has been played 3+ times
+        key   = _safe_key(title or query)
+        index = _load_index()
+        if key in index:
+            count = index[key].get("play_count", 0)
+            if count >=2:
+                print(f"\n  📥 Smart cache: saving frequently played track…")
+                save_offline(query, title)
+
+    #mode == "manual" → do nothing
+
+#--- Internal helpers ---------------------------------------------------------------------------------------------------------
+def _touch(key: str) -> None:
+    """Update last_played and increment play_count."""
+    index = _load_index()
+    if key in index:
+        index[key]["last_played"] = time.time()
+        index[key]["play_count"]  = index[key].get("play_count", 0) + 1
+        _save_index(index)
+
+def _evict_if_needed() -> None:
+    """Remove least-recently-played tracks until under the size limit."""
+    limit = get_cache_limit_mb()
+    index = _load_index()
+
+    while cache_size_mb() >= limit and index:
+        #LRU: remove the track with the oldest last_played
+        lru_key = min(index, key=lambda k: index[k].get("last_played", 0))
+        print(f"    ♻️ Cache full - evicting: {index[lru_key]['title']}")
+        _remove_file(index[lru_key].get("path"))
+        del index[lru_key]
+        _save_index(index)
+
+def _find_output(cache_dir: str, key: str) -> str | None:
+    for ext in (".opus", ".webm", ".m4a", ".ogg"):
+        p = os.path.join(cache_dir, f"{key}{ext}")
+        if os.path.exists(p):
+            return p
+    return None
+
+def _remove_file(path: str | None) -> None:
+    if path and os.path.exists(path):
+        try:
+            os.remove(path)
+        except OSError:
+            pass

riff/cli.py

@@ -0,0 +1,454 @@
+"""
+riff/cli.py
+Command-line interface for Riff v2.0.0
+
+Usage:
+    python riff.py play <file>
+    python riff.py search <query>
+    python riff.py stream <query or URL>
+    python riff.py video <query or URL>
+    python riff.py save <query or URL>         --save offline
+    python riff.py browse
+    python riff.py tui
+
+    python riff.py playlist save <name>
+    python riff.py playlist load <name>
+    python riff.py playlist list
+    python riff.py playlist fetch <platform> [name]
+    python riff.py playlist delete <name>
+
+    python riff.py account connect <platform>
+    python riff.py account sync [platform|all]
+    python riff.py account list
+    python riff.py account autosync <platform> <on|off>
+
+    python riff.py cache list
+    python riff.py cache clear [name]
+
+    python riff.py config show
+    python riff.py config set <key.path> <value>
+
+    python riff.py info
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import argparse
+
+from riff       import __version__
+
+
+# --- Banner ------------------------------------------------------------------------------------------------------
+BANNER = r"""
+    ▮▮▮▮▮▮◱     ▮▮◱     ▮▮▮▮▮▮▮▮◱   ▮▮▮▮▮▮▮▮◱
+    ▮▮◲⊟⊟▮▮◱    ▮▮◫     ▮▮▮◲⊟⊟⊟⊟◰   ▮▮▮◲⊟⊟⊟⊟◰
+    ▮▮▮▮▮▮◲◰    ▮▮◫     ▮▮▮▮▮▮◱     ▮▮▮▮▮▮◱
+    ▮▮◲⊟⊟▮▮◱    ▮▮◫     ▮▮▮◲⊟⊟◰     ▮▮▮◲⊟⊟◰
+    ▮▮◫   ▮▮◫   ▮▮◫     ▮▮▮◫        ▮▮▮◫
+     ◳◰    ◳◰    ◳◰      ◳⊟◰         ◳⊟◰      Terminal Media Player  v{version}
+""".format(version=__version__)
+
+
+def main():
+    #--- Startup sync (background) -----------------------------------------------------------------------------------
+    from riff.sync import startup_sync
+    startup_sync()
+
+    parser = argparse.ArgumentParser(
+        prog="riff",
+        description="Riff - Terminal Media Player",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Platforms: spotify | ytmusic | soundcloud
+Cache modes: ask | always | manual | smart
+
+Examples:
+    python riff.py stream "lofi hip hop"
+    python riff.py save "https://youtu.be/..."
+    python riff.py playlist fetch spotify "My Mix"
+    python riff.py account connect spotify
+    python riff.py account sync all
+    python riff.py account autosync ytmusic on
+    python riff.py cache list
+    python riff.py config set cache.mode always
+    python riff.py config set cache.size_limit_mb 2048
+    python riff.py play "C:/Music/song.mp3"
+    python riff.py search "bohemian rphapsody"
+    python riff.py browse
+    python riff.py info
+        """,
+    )
+    
+    parser.add_argument("--version", action="version", version=f"Riff {__version__}")
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    #play
+    sp = sub.add_parser("play", help="Play a local file")
+    sp.add_argument("file")
+    sp.add_argument("--video", action="store_true")
+    sp.add_argument("--audio", action="store_true")
+
+    #search
+    sp = sub.add_parser("search", help="Search local storage and play")
+    sp.add_argument("query", nargs="?", default="")
+    sp.add_argument("--audio", action="store_true")
+    sp.add_argument("--video", action="store_true")
+    sp.add_argument("--queue", action="store_true")
+    sp.add_argument("--shuffle", action="store_true")
+
+    #stream
+    sp = sub.add_parser("stream", help="Stream audio from the internet")
+    sp.add_argument("query")
+    sp.add_argument("--save",action="store_true", help="Save offline after streaming")
+
+    #video
+    sp = sub.add_parser("video", help="Stream video from the internet")
+    sp.add_argument("query")
+
+    #save
+    sub.add_parser("save", help="Save a track offline").add_argument("query")
+
+    #browse
+    sub.add_parser("browse", help="Interactively browse your media library")
+
+    #tui
+    sub.add_parser("tui", help="Launch the full TUI interface")
+
+    #playlist
+    sp = sub.add_parser("playlist", help="Manage playlists")
+    sp.add_argument("action", choices=["save", "load", "list", "fetch", "delete"])
+    sp.add_argument("args", nargs="*")
+
+    #account
+    sp = sub.add_parser("account", help="Manage music platform accounts")
+    sp.add_argument("action", choices=["connect", "sync", "list", "autosync"])
+    sp.add_argument("args", nargs="*")
+
+    #cache
+    sp = sub.add_parser("cache", help="Manage offline cache")
+    sp.add_argument("action", choices=["list", "clear"])
+    sp.add_argument("args", nargs="*")
+
+    #config
+    sp = sub.add_parser("config", help="View or update Riff settings")
+    sp.add_argument("action", choices=["show", "set"])
+    sp.add_argument("args", nargs="*")
+    
+    #info
+    sub.add_parser("info", help="Show system and dependency info")
+
+    #--- Parse ---------------------------------------------------------------------------------------
+    args = parser.parse_args()
+
+    if args.command is None:
+        print(BANNER)
+        parser.print_help()
+        return
+    
+    #--- Dispatch -------------------------------------------------------------------------------------
+    dispatch = {
+        "play":     _cmd_play,
+        "search":   _cmd_search,
+        "stream":   _cmd_stream,
+        "video":    _cmd_stream,
+        "save":     _cmd_save,
+        "browse":   _cmd_browse,
+        "tui":      _cmd_tui,
+        "playlist": _cmd_playlist,
+        "account":  _cmd_account,
+        "cache":    _cmd_cache,
+        "config":   _cmd_config,
+        "info":     _cmd_info,
+    }
+    dispatch[args.command](args)
+
+#--- Command Handlers -------------------------------------------------------------------------
+
+def _cmd_play(args):
+    from riff.player import play
+    video = True if args.video else (False if args.audio else None)
+    play(args.file, video=video)
+
+
+def _cmd_search(args):
+    from riff.search import find_local_media, fzf_pick
+    from riff.player import play, play_queue
+
+    mode  = "audio" if args.audio else ("video" if args.video else "all")
+    query = args.query
+
+    print(f"\n🔍 Searching local library{' for: ' + query if query else ''}…")
+    results = find_local_media(query=query, mode=mode)
+
+    if not results:
+        print(" No files found.")
+        return
+    
+    print(f"    Found {len(results)} file(s).\n")
+
+    if args.queue:
+        play_queue(results, shuffle=args.shuffle)
+        return
+    
+    chosen = fzf_pick(results)
+    if chosen:
+        play(chosen)
+
+
+def _cmd_stream(args):
+    from riff.stream import stream
+    from riff.cache  import maybe_cache
+
+    video = (args.command == "video")
+    print(f"\n🌐 Streaming {'video' if video else 'audio'}: {args.query}\n")
+    stream(args.query, video=video)
+
+    #Post-stream cache prompt (audio only)
+    if not video:
+        save_flag = getattr(args, "save", False)
+        if save_flag:
+            from riff.cache import save_offline
+            save_offline(args.query)
+        else:
+            maybe_cache(args.query)
+
+
+def _cmd_save(args):
+    from riff.cache import save_offline
+    print(f"\n💾 Saving offline: {args.query}\n")
+    save_offline(args.query)
+
+
+def _cmd_browse(args=None):
+    from riff.search import find_local_media, fzf_pick
+    from riff.player import play
+
+    print("\n📂 Browsing media library…\n")
+    results = find_local_media(query="", mode="all", limit=500)
+    if not results:
+        print(" No media files found.")
+        return
+    print(f"    {len(results)} file(s). Arrow keys to browse, Enter to play.\n")
+    chosen = fzf_pick(results)
+    if chosen:
+        play(chosen)
+
+
+def _cmd_tui(args=None):
+    try:
+        from riff.tui import RiffApp
+        RiffApp().run()
+    except ImportError as e:
+        print(f"✕ TUI requires textual: pip install textual\n  ({e})")
+
+
+def _cmd_playlist(args):
+    from riff import playlist as pl
+
+    action = args.action
+    pargs  = args.args
+
+    if action == "list":
+        names = pl.list_all()
+        if not names:
+            print("\n   No saved playlists.")
+        else:
+            print(f"\n  🗒️ Saved playlists ({len(names)}):")
+            for n in names:
+                print(f"    • {n}")
+
+    elif action == "save":
+        if not pargs:
+            print(" Usage: riff playlist save <name>")
+            return
+        name = pargs[0]
+        #Save current search results or prompt for files
+        print(f"\n  Enter file paths to add (one per line, blank to finish):")
+        paths = []
+        while True:
+            try:
+                line = input("  > ").strip()
+                if not line:
+                    break
+                if os.path.exists(line):
+                    paths.append(line)
+                else:
+                    print(f"    ✕ Not found: {line}")
+            except (KeyboardInterrupt, EOFError):
+                break
+        if paths:
+            pl.save(name, paths)
+
+    elif action == "load":
+        if not pargs:
+            print(" Usage: riff playlist load <name>")
+            return
+        from riff.player import play_queue
+        paths = pl.load(pargs[0])
+        if paths:
+            play_queue(paths)
+
+    elif action == "fetch":
+        if not pargs:
+            print(" Usage: riff playlist fetch <platform> [playlist-name]")
+            print(" Platforms: spotify | ytmusic | soundcloud")
+            return
+        platform = pargs[0]
+        name     = pargs[1]
+        pl.save_from_platform(platform, name)
+
+    elif action == "delete":
+        if not pargs:
+            print(" Usage: riff playlist delete <name>")
+            return
+        if pl.delete(pargs[0]):
+            print(f"    ✓ Deleted playlist: {pargs[0]}")
+        else:
+            print(f"    ✕ Not found: {pargs[0]}")
+
+
+def _cmd_account(args):
+    from riff.sync   import sync_account, set_autosync
+    from riff.config import get_account, RIFF_DIR
+
+    action = args.action
+    pargs  = args.args
+
+    if action == "list":
+        print("\n   🔗 Connected Accounts:")
+        print(" --------------------------------------------------------------------------------")
+        for platform in ("spotify", "ytmusic", "soundcloud"):
+            acc      = get_account(platform)
+            enabled  = acc.get("enabled", False)
+            autosync = acc.get("auto_sync", False)
+            status   = "✓ connected" if enabled else "✕ not connected"
+            sync_str = " [auto-sync ON]" if autosync else " [auto-sync OFF]"
+            print(f"    {platform:<12} {status}{sync_str if enabled else ''}")
+        print()
+
+    elif action == "connect":
+        if not pargs:
+            print(" Usage: riff account connect <platform>")
+            print(" Platforms: spotify | ytmusic | soundcloud")
+            return
+        platform = pargs[0].lower()
+        if platform == "spotify":
+            from riff.spotify import connect
+        elif platform == "ytmusic":
+            from riff.ytmusic import connect
+        elif platform == "soundcloud":
+            from riff.soundcloud import connect
+        else:
+            print(f"    Unknown platform: {platform}")
+            return
+        connect()
+
+    elif action == "sync":
+        platform = pargs[0].lower() if pargs else "all"
+        offline  = "--offline" in pargs
+        print(f"\n  🔁 Syncing: {platform}")
+        sync_account(platform, offline=offline)
+
+    elif action == "autosync":
+        if len(pargs) < 2:
+            print(" Usage: riff account autosync <platform> <on|off>")
+            return
+        platform = pargs[0].lower()
+        enabled  = pargs[1].lower() in ("on", "true", "yes", "1")
+        set_autosync(platform, enabled)
+
+
+def _cmd_cache(args):
+    from riff.cache import list_cache, clear_cache, cache_size_mb
+
+    action = args.action
+    pargs  = args.args
+
+    if action == "list":
+        tracks = list_cache()
+        total  = cache_size_mb()
+        if not tracks:
+            print("\n   Cache is empty.")
+            return
+        print(f"\n  💾 Cached tracks ({len(tracks)}) - {total:.1f} MB used:\n")
+        for t in tracks:
+            import datetime
+            played = datetime.datetime.fromtimestamp(
+                t.get("last_played", 0)
+            ).strftime("%b %d")
+            print(f"    [{t.get('size_mb', 0):.1f}MB] {t['title']:<50}  last: {played}")
+        print()
+
+    elif action == "clear":
+        name = pargs[0] if pargs else None
+        if name is None:
+            confirm = input("   Clear entire cache? [y/N]: ").strip().lower()
+            if confirm in ("y", "yes"):
+                clear_cache()
+        else:
+            clear_cache(name)
+
+
+def _cmd_config(args):
+    from riff.config import load, set_value
+
+    action = args.action
+    pargs  = args.args
+
+    if action == "show":
+        import json
+        cfg = load()
+        print("\n   ⚙️ Riff Configuration:\n")
+        print(json.dumps(cfg, indent=4))
+        print()
+
+    elif action == "set":
+        if len(pargs) < 2:
+            print(" Usage: riff config set <key.path> <value>")
+            print(" Examples:")
+            print("     riff config set cache.mode always")
+            print("     riff config cache.size_limit_mb 2048")
+            print("     riff config accounts.spotify.auto_sync true")
+            return
+        key, value = pargs[0], pargs[1]
+        if set_value(key, value):
+            print(f"    ✓ Set {key} = {value}")
+        else:
+            print(f"    ✕ Unknown config key: {key}")
+
+
+def _cmd_info(args=None):
+    from riff.utils  import find_mpv, find_fzf, find_ytdlp, get_media_roots, is_online
+    from riff.config import load, get_cache_dir
+    from riff.cache  import cache_size_mb
+
+    print(BANNER)
+    print(f"    Version   : Riff {__version__}")
+    print(f"    Python    : {sys.version.split()[0]}")
+    print(f"    Platform  : {sys.platform}")
+    print()
+    print(" Dependencies:")
+    print(f"    mpv       : {'✓    ' + find_mpv() if find_mpv() else '✕   not found (winget install shinchiro.mpv)'}")
+    print(f"    yt-dlp    : {'✓    ' + find_ytdlp() if find_ytdlp() else '✕   not found (pip install yt-dlp)'}")
+    print(f"    fzf       : {'✓    ' + find_fzf() if find_fzf() else '✕   not found - optional (winget install fzf)'}")
+    print()
+    print(" Accounts:")
+    for platform in ("spotify", "ytmusic", "soundcloud"):
+        from riff.config import get_account
+        acc = get_account(platform)
+        status = "✓ connected" if acc.get("enabled") else "✕ not connected"
+        print(f"    {platform:<12}: {status}")
+    print()
+    print(" Cache:")
+    print(f"    Directory: {get_cache_dir()}")
+    print(f"    Used     : {cache_size_mb():.1f} MB / {load()['cache']['size_limit_mb']} MB")
+    print(f"    Mode     : {load()['cache']['mode']}")
+    print()
+    print(" Media roots:")
+    for root in get_media_roots():
+        print(f"    {root}")
+    print()
+    print(f"    Internet : {'✓ online' if is_online() else '✕ offline'}")
+    print()