slopatronic 0.1.0__tar.gz

slopatronic-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: slopatronic
+Version: 0.1.0
+Summary: Find music on YouTube (audio only), keep a library, and play it in the background.
+Requires-Python: >=3.10
+Requires-Dist: textual>=0.60
+Requires-Dist: rich>=13.0
+Requires-Dist: rapidfuzz
+Requires-Dist: yt-dlp
+Requires-Dist: imageio-ffmpeg
+Requires-Dist: miniaudio
+Requires-Dist: questionary

slopatronic-0.1.0/README.md

@@ -0,0 +1,55 @@
+# slopatronic
+
+Terminal music player that finds tracks on YouTube, Bandcamp and Mixcloud, downloads the audio, and keeps playing in the background while you do other things.
+
+## Install
+
+Requires Python 3.10+ (ffmpeg is bundled via `imageio-ffmpeg`).
+
+```sh
+pip install -r requirements.txt
+```
+
+On Windows, use `slopatronic.cmd` from the parent directory (or set `PYTHONPATH` yourself). On Linux/macOS, run from the parent directory:
+
+```sh
+python -m slopatronic
+```
+
+## Usage
+
+```sh
+slopatronic find <query>    # search all sources, tick what you want, download audio only
+slopatronic list            # show downloaded tracks
+slopatronic add <query>     # fuzzy-match a track and append it to the queue
+slopatronic play <query>    # play now, replacing whatever is on
+slopatronic pause / next / prev / stop
+slopatronic queue           # show the queue with a live progress view
+slopatronic ui              # full TUI
+```
+
+`<query>` can be a library index number, a fuzzy match, or a search string.
+
+### TUI
+
+`slopatronic ui` opens a Textual app with three tabs: search results, library tree, and now playing (queue, controls, volume, a live level meter). There's a command mode and a filter mode; tables are clickable.
+
+## How it works
+
+- A detached daemon owns the queue and decodes tracks with ffmpeg to raw PCM, streamed through miniaudio. CLI commands talk to it over a local socket (port 47651), so music keeps playing after the terminal closes.
+- Downloads go to `~/.slopatronic` by default. No re-encoding — the best audio stream is saved as-is.
+- You can register extra music folders in `~/.slopatronic/config.json` (with optional recursive scanning); your own files are never touched.
+- Tracks are loudness-normalized on the fly: each queued track is measured with ebur128, and a gain is applied to hit the target in config (default -12 LUFS), capped so loud sections never exceed a -6 LUFS ceiling. Gains live in memory only.
+
+## Config
+
+`~/.slopatronic/config.json`, created on first run:
+
+```json
+{
+  "folders": [{"path": "/abs/dir", "recursive": false}],
+  "volume": 1.0,
+  "loudness_target": -12.0,
+  "loudness_correction": true
+}
+```

slopatronic-0.1.0/__init__.py

@@ -0,0 +1 @@
+"""Find music on YouTube (audio only), keep a library, and play it in the background."""

slopatronic-0.1.0/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

slopatronic-0.1.0/cli.py

@@ -0,0 +1,171 @@
+import argparse
+import time
+
+import questionary
+
+
+from .client import ensure_daemon, request
+from .downloader import download, search_all
+from .library import fuzzy_paths, library_files, library_tree
+from .ui import console, queue_table, run_ui
+
+
+def pick_youtube(query):
+    """Search every source (shared search_all), print results grouped by
+    source with per-source failure reasons, then let the user tick tracks
+    to download (the original checkbox picker)."""
+    flat = []  # (source label, entry) across all sources, for the picker
+    for source, entries, error in search_all(query):
+        if error:
+            console.print(f"[red]{source}: search failed — "
+                          f"{type(error).__name__}: {error}[/]")
+            continue
+        console.print(f"[green]{source}: {len(entries)} results:[/]")
+        for i, entry in enumerate(entries, 1):
+            title = entry.get("title", "untitled")
+            url = entry.get("url") or entry.get("id") or ""
+            console.print(f"  {i:2d}. {title}  [dim]{url}[/]")
+            flat.append((source, entry))
+    if not flat:
+        console.print("[red]No results.[/]")
+        return []
+    picked = questionary.checkbox(
+        "Tick tracks with space, then Enter to download:",
+        choices=[questionary.Choice(f"[{source}] {e.get('title', 'untitled')}",
+                                    value=e)
+                 for source, e in flat],
+        use_search_filter=True,
+        use_jk_keys=False,
+    ).ask()
+    if picked is None:
+        return []
+    if not picked:
+        console.print("[dim]Nothing ticked. Press space on a track to tick it, then Enter.[/]")
+    return picked
+
+
+def fetch(entry):
+    """Download one search result into the library. Returns the path, or None on failure."""
+    title = entry.get("title", "untitled")
+    try:
+        with console.status(f"Downloading {title}..."):
+            path, outcome = download(entry)
+    except Exception as exc:  # one failed track should not stop the rest
+        console.print(f"  [red]✘[/] {title}: {exc}")
+        return None
+    console.print(f"  [green]✔[/] {title} [dim]({outcome})[/]")
+    return path
+
+
+def pick_library_track(query):
+    """Resolve a query to one library track: a number, a fuzzy match, or the best hit."""
+    files = library_files()
+    if not files:
+        console.print("[dim]Library is empty. Use find first.[/]")
+        return None
+    if query.isdigit() and 1 <= int(query) <= len(files):
+        return files[int(query) - 1]
+    candidates = fuzzy_paths(query, files) if query else files
+    if not candidates:
+        console.print(f"[red]No library match for '{query}'.[/] Try: find {query}")
+        return None
+    return candidates[0]  # best fuzzy hit
+
+
+def cmd_find(args):
+    for entry in pick_youtube(" ".join(args.query)):
+        fetch(entry)
+
+
+def cmd_add(args):
+    chosen = pick_library_track(" ".join(args.query).strip())
+    if chosen is None:
+        return
+    ensure_daemon()
+    if request("add", paths=[str(chosen)]) is None:
+        console.print("[red]The player did not respond. Try again.[/]")
+        return
+    console.print(f"Queued: {chosen.stem}")
+
+
+def cmd_play(args):
+    chosen = pick_library_track(" ".join(args.query).strip())
+    if chosen is None:
+        return
+    ensure_daemon()
+    response = request("play", path=str(chosen))
+    if response is None or "error" in response:
+        reason = response.get("error", "") if response else "no response"
+        console.print(f"[red]Could not play {chosen.stem}:[/] {reason}")
+        return
+    console.print(f"Playing: {chosen.stem}")
+
+
+def cmd_list(_args):
+    # same tree the TUI Library tab shows: folder roots, subfolders, tracks
+    rows = library_tree()
+    files = [p for kind, _d, _n, p in rows if kind == "file"]
+    if not files:
+        console.print("[dim]No music yet. Use find first.[/]")
+        return
+    numbers = iter(range(1, len(files) + 1))
+    for kind, depth, name, path in rows:
+        if kind == "dir":
+            console.print(f"{'  ' * depth}[bold]{name}/[/]")
+        else:
+            console.print(f"{'  ' * depth}[dim]{next(numbers):>3d}.[/] {name}")
+
+
+def cmd_queue(_args):
+    st = request("status")
+    if st is None or not st["active"]:
+        console.print("[dim]Nothing playing.[/]")
+        return
+    console.print(queue_table(st))
+
+
+def cmd_ui(_args):
+    run_ui()
+
+
+def control(cmd):
+    def run(_args):
+        if request(cmd) is None:
+            console.print("[dim]Nothing playing.[/]")
+    return run
+
+
+def cmd_stop(_args):
+    if request("stop") is None:
+        console.print("[dim]The player is not running.[/]")
+        return
+    deadline = time.time() + 3  # wait for the port to close so the next command starts a fresh player
+    while time.time() < deadline and request("status") is not None:
+        time.sleep(0.1)
+    console.print("Player stopped.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Find music on YouTube (audio only) and play it in the background.")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    commands = {
+        "find": (cmd_find, "search YouTube and download audio only", "+"),
+        "add": (cmd_add, "add a library track to the end of the queue", "*"),
+        "play": (cmd_play, "play a library track now, replacing the current one", "*"),
+        "list": (cmd_list, "list downloaded tracks", None),
+        "queue": (cmd_queue, "show the current queue", None),
+        "ui": (cmd_ui, "full TUI: search, download, queue and player controls", None),
+        "pause": (control("pause"), "pause or resume", None),
+        "next": (control("next"), "skip to the next track", None),
+        "prev": (control("prev"), "go back to the previous track", None),
+        "stop": (cmd_stop, "stop the background player", None),
+    }
+    for name, (func, help_text, nargs) in commands.items():
+        p = sub.add_parser(name, help=help_text)
+        if nargs:
+            p.add_argument("query", nargs=nargs)
+        p.set_defaults(func=func)
+
+    args = parser.parse_args()
+    args.func(args)

slopatronic-0.1.0/client.py

@@ -0,0 +1,49 @@
+import json
+import socket
+import subprocess
+import sys
+import time
+
+from .config import HOST, PACKAGE_PARENT, PORT
+
+
+def request(cmd, _timeout=2, **kwargs):
+    """Send one command to the background player. Returns None if it is not running."""
+    payload = json.dumps({"cmd": cmd, **kwargs}) + "\n"
+    try:
+        with socket.create_connection((HOST, PORT), timeout=_timeout) as sock:
+            sock.sendall(payload.encode())
+            line = sock.makefile("rb").readline()
+        return json.loads(line)
+    except (OSError, ValueError):
+        return None
+
+
+def _spawn_detached():
+    """Start a detached background process on Windows or POSIX."""
+    kwargs = {"stdin": subprocess.DEVNULL, "stdout": subprocess.DEVNULL,
+              "stderr": subprocess.DEVNULL, "close_fds": True}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = (
+            subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW
+        )
+    else:
+        kwargs["start_new_session"] = True
+    return subprocess.Popen(
+        [sys.executable, "-c", "from slopatronic.daemon import serve; serve()"],
+        cwd=PACKAGE_PARENT,
+        **kwargs,
+    )
+
+
+def ensure_daemon():
+    """Start the background player if it is not already running."""
+    if request("status") is not None:
+        return
+    _spawn_detached()
+    deadline = time.time() + 5
+    while time.time() < deadline:
+        if request("status") is not None:
+            return
+        time.sleep(0.1)
+    raise SystemExit("Could not start the background player.")

slopatronic-0.1.0/config.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+
+# Everything lives in one hidden folder; the config is one file inside it.
+LIBRARY = Path.home() / ".slopatronic"
+CONFIG_FILE = LIBRARY / "config.json"
+
+DEFAULT_CONFIG = {
+    "folders": [],   # extra library folders: [{"path": ..., "recursive": ...}]
+    "volume": 1.0,   # remembered player volume (0..1)
+    "loudness_target": -12.0,  # common-sense target loudness (LUFS) tracks are adjusted to
+    "loudness_correction": True,  # toggle: adjust track volume to the loudness target
+}
+EXTENSIONS = {".m4a", ".webm", ".opus", ".mp3", ".ogg", ".wav", ".flac"}
+
+# The background player listens on this local port.
+HOST = "127.0.0.1"
+PORT = 47651
+
+SAMPLE_RATE = 44100
+CHANNELS = 2
+FRAMES_PER_SECOND = SAMPLE_RATE * CHANNELS
+
+METER_BANDS = 24
+METER_FULL_SCALE = 12000
+BAR_CHARS = "▁▂▃▄▅▆▇█"
+
+# Folder that contains the slopatronic package, used to start the player in the background.
+PACKAGE_PARENT = Path(__file__).resolve().parents[1]
+
+
+def ensure_config():
+    """Always make sure the config file exists (even if empty)."""
+    LIBRARY.mkdir(parents=True, exist_ok=True)
+    if not CONFIG_FILE.exists():
+        save_config(dict(DEFAULT_CONFIG))
+
+
+def load_config():
+    """The config dict, merged over the defaults; generates the file if needed."""
+    ensure_config()
+    data = dict(DEFAULT_CONFIG)
+    try:
+        data.update(json.loads(CONFIG_FILE.read_text(encoding="utf-8")))
+    except (OSError, ValueError):
+        pass
+    return data
+
+
+def save_config(data):
+    LIBRARY.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
+def load_volume():
+    return min(1.0, max(0.0, float(load_config()["volume"])))
+
+
+def save_volume(volume):
+    data = load_config()
+    data["volume"] = round(min(1.0, max(0.0, float(volume))), 3)
+    save_config(data)
+
+
+def load_target():
+    """The common-sense loudness target (LUFS) from the config file."""
+    return float(load_config()["loudness_target"])
+
+
+def correction_enabled():
+    """Whether loudness correction is toggled on in the config file."""
+    return bool(load_config()["loudness_correction"])

slopatronic-0.1.0/daemon.py

@@ -0,0 +1,189 @@
+import json
+import socketserver
+import threading
+import time
+from pathlib import Path
+
+from .config import HOST, PORT, correction_enabled, load_volume, save_volume
+from .loudness import gain_multiplier, measure_gain
+from .player import Player
+
+
+class Daemon:
+    """Owns the queue and the player. Requests come in over a local socket."""
+
+    def __init__(self):
+        self.lock = threading.RLock()
+        self.queue = []
+        self.index = 0
+        self.player = Player()
+        # the knob; per-track normalization gain is separate
+        self.user_volume = load_volume()
+        self.player.set_volume(self.user_volume)
+        # in-memory loudness gains (dB) per queued track path, measured when
+        # a track is queued; never written to disk, gone when the daemon stops
+        self.gains = {}
+        self.server = None
+        self.stopping = threading.Event()
+
+    def _measure_async(self, paths):
+        """Measure queued tracks in the background and cache the gain in
+        memory; if one of them is already playing, apply it as soon as known.
+        Skipped entirely when the loudness_correction toggle is off."""
+        if not correction_enabled():
+            return
+
+        def work():
+            for path in paths:
+                gain = measure_gain(path)
+                with self.lock:
+                    self.gains[str(path)] = gain or 0.0
+                    if (self.player.loaded and self.index < len(self.queue)
+                            and str(self.queue[self.index]) == str(path)):
+                        self.player.set_gain(gain_multiplier(gain))
+        threading.Thread(target=work, daemon=True).start()
+
+    def _load_current(self):
+        self.player.load(self.queue[self.index])
+        # passive volume normalization: the in-memory gain measured at queue
+        # time, applied on top of the user's volume knob; neutral unless the
+        # loudness_correction toggle is on and a measured gain exists
+        gain = self.gains.get(str(self.queue[self.index]), 0.0) if correction_enabled() else 0.0
+        self.player.set_gain(gain_multiplier(gain))
+
+    def _go_idle(self):
+        self.player.stop()
+        self.queue = []
+        self.index = 0
+        self.gains.clear()
+
+    def _advance(self):
+        if self.index + 1 < len(self.queue):
+            self.index += 1
+            self._load_current()
+        else:
+            self._go_idle()
+
+    def status(self):
+        if not self.player.loaded:
+            return {"active": False, "queue": [], "index": 0, "paused": False,
+                    "elapsed": 0, "duration": 0, "meter": "", "volume": self.player.volume}
+        return {
+            "active": True,
+            "queue": [p.stem for p in self.queue],
+            # clamp defensively: no client must ever see an out-of-range index
+            "index": min(self.index, len(self.queue) - 1),
+            "paused": self.player.paused,
+            "elapsed": self.player.elapsed(),
+            "duration": self.player.duration(),
+            "meter": self.player.meter(),
+            "volume": self.user_volume,
+        }
+
+    def handle(self, req):
+        cmd = req.get("cmd")
+        with self.lock:
+            if cmd == "status":
+                pass
+            elif cmd == "add":
+                paths = [Path(p) for p in req["paths"]]
+                if paths and not self.player.loaded:
+                    self.queue = paths
+                    self.index = 0
+                    self._load_current()
+                else:
+                    self.queue.extend(paths)
+                self._measure_async(paths)
+            elif cmd == "remove":
+                # drop one queued track; removing the currently playing one
+                # skips straight to the track that takes its slot
+                idx = int(req["index"])
+                if not (0 <= idx < len(self.queue)):
+                    return {"error": "no such queue index"}
+                popped = self.queue.pop(idx)
+                self.gains.pop(str(popped), None)
+                if idx < self.index:
+                    self.index -= 1
+                elif idx == self.index:
+                    if not self.queue or idx == len(self.queue):
+                        # removed the playing track and nothing follows it
+                        # (queue drained, or it was the last element):
+                        # nothing more to play — stop and clear, exactly like
+                        # a natural end-of-queue
+                        self._go_idle()
+                    else:
+                        self._load_current()  # play the new occupant of the slot
+                elif self.index >= len(self.queue):
+                    self.index = max(0, len(self.queue) - 1)
+            elif cmd == "play":
+                # playskip: the chosen track replaces the current one and starts now.
+                path = Path(req["path"])
+                if self.player.loaded:
+                    self.queue[self.index] = path
+                else:
+                    self.queue = [path]
+                    self.index = 0
+                self._load_current()
+                self._measure_async([path])
+            elif cmd == "pause" and self.player.loaded:
+                self.player.toggle_pause()
+            elif cmd == "next" and self.player.loaded:
+                self._advance()
+            elif cmd == "prev" and self.player.loaded and self.index > 0:
+                self.index -= 1
+                self._load_current()
+            elif cmd == "seek" and self.player.loaded:
+                self.player.seek(float(req["seconds"]))
+            elif cmd == "volume":
+                self.user_volume = min(1.0, max(0.0, self.user_volume + float(req["delta"])))
+                self.player.set_volume(self.user_volume)
+                save_volume(self.user_volume)  # remembered for the next start
+            elif cmd == "stop":
+                self._go_idle()
+                self.stopping.set()
+                threading.Thread(target=self.server.shutdown, daemon=True).start()
+                return {"ok": True}
+            else:
+                return {"error": f"unknown or inapplicable command: {cmd}"}
+            return self.status()
+
+    def monitor(self):
+        """Advances to the next track when the current one has finished."""
+        while not self.stopping.is_set():
+            time.sleep(0.2)
+            with self.lock:
+                done = self.player.loaded and self.player.finished()
+            if done:
+                time.sleep(0.5)  # let the device drain its buffer
+                with self.lock:
+                    if self.player.loaded and self.player.finished():
+                        self._advance()
+
+
+class _Handler(socketserver.StreamRequestHandler):
+    def handle(self):
+        line = self.rfile.readline()
+        if not line:
+            return
+        try:
+            response = self.server.state.handle(json.loads(line))
+        except Exception as exc:  # a bad request must not take the player down
+            response = {"error": str(exc)}
+        self.wfile.write((json.dumps(response) + "\n").encode())
+
+
+class _Server(socketserver.ThreadingTCPServer):
+    daemon_threads = True
+
+
+def serve():
+    state = Daemon()
+    server = _Server((HOST, PORT), _Handler)
+    server.state = state
+    state.server = server
+    threading.Thread(target=state.monitor, daemon=True).start()
+    try:
+        server.serve_forever()
+    finally:
+        server.server_close()
+        state.player.close()

slopatronic-0.1.0/downloader.py

@@ -0,0 +1,114 @@
+import json
+import re
+import urllib.request
+from urllib.parse import quote
+from pathlib import Path
+
+import imageio_ffmpeg
+from yt_dlp import YoutubeDL
+
+from .config import LIBRARY
+
+
+def search(query, limit=10, prefix="ytsearch"):
+    """Search via any yt-dlp search prefix (ytsearch, scsearch, ...)."""
+    opts = {"quiet": True, "skip_download": True, "extract_flat": "in_playlist"}
+    with YoutubeDL(opts) as ydl:
+        info = ydl.extract_info(f"{prefix}{limit}:{query}", download=False)
+    return [e for e in info.get("entries", []) if e]
+
+
+def _json_url(url, timeout=8):
+    """Small helper: GET a JSON endpoint with a browser-ish User-Agent."""
+    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read().decode("utf-8", "replace"))
+
+
+def bandcamp_search(query, limit=10):
+    """Bandcamp has no yt-dlp search prefix; use the same autocomplete_elastic
+    endpoint the Bandcamp website search box calls from the browser (POST,
+    no API key, not bot-blocked)."""
+    body = json.dumps({"search_text": query, "search_filter": "t",
+                       "full_page": False, "fan_id": None}).encode()
+    req = urllib.request.Request(
+        "https://bandcamp.com/api/bcsearch_public_api/1/autocomplete_elastic",
+        data=body, headers={"User-Agent": "Mozilla/5.0",
+                            "Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=8) as resp:
+        data = json.loads(resp.read().decode("utf-8", "replace"))
+    results = []
+    for hit in data.get("auto", {}).get("results", []):
+        url = hit.get("item_url_path")
+        if hit.get("type") != "t" or not url:  # tracks only
+            continue
+        name = hit.get("name", "untitled")
+        band = hit.get("band_name", "")
+        results.append({"id": url, "url": url,
+                        "title": f"{band} - {name}" if band else name,
+                        "extractor": "bandcamp"})
+        if len(results) >= limit:
+            break
+    if not results:
+        raise RuntimeError("no results on Bandcamp")
+    return results
+
+
+def mixcloud_search(query, limit=10):
+    """Mixcloud public search API; returns uploads yt-dlp can download."""
+    data = _json_url(
+        "https://api.mixcloud.com/search/?q=" + quote(query)
+        + "&type=cloudcast&limit=" + str(limit))
+    return [{"id": item.get("key", ""), "url": item.get("url"),
+             "title": item.get("name", "untitled"),
+             "extractor": "mixcloud"}
+            for item in data.get("data", [])[:limit] if item.get("url")]
+
+
+# Every source the Search tab queries: the two yt-dlp search prefixes plus
+# the two public-endpoint searches (still downloaded through yt-dlp).
+SEARCH_SOURCES = (
+    ("YouTube", lambda q, n: search(q, n, "ytsearch")),
+    ("SoundCloud", lambda q, n: search(q, n, "scsearch")),
+    ("Bandcamp", bandcamp_search),
+    ("Mixcloud", mixcloud_search),
+)
+
+# display order of the grouped Search tab
+SOURCE_ORDER = [name for name, _fn in SEARCH_SOURCES]
+
+
+def search_all(query, limit=10):
+    """The single shared multi-source search, used by both the CLI and the
+    TUI. Runs every source in SEARCH_SOURCES and returns one tuple per
+    source: (name, entries, error) — error is None on success so callers
+    can show exactly why a source failed."""
+    out = []
+    for name, fn in SEARCH_SOURCES:
+        try:
+            out.append((name, fn(query, limit), None))
+        except Exception as exc:
+            out.append((name, [], exc))
+    return out
+
+
+def download(entry):
+    """Save the entry's best audio stream in the library, without re-encoding. Returns (path, outcome)."""
+    url = (entry.get("webpage_url") or entry.get("url")
+           or f"https://www.youtube.com/watch?v={entry['id']}")
+    opts = {
+        "quiet": True,
+        "noprogress": True,
+        "noplaylist": True,
+        "format": "bestaudio/best",
+        "outtmpl": str(LIBRARY / "%(title)s.%(ext)s"),
+        "ffmpeg_location": imageio_ffmpeg.get_ffmpeg_exe(),  # yt-dlp needs it to fix up some containers
+    }
+    LIBRARY.mkdir(parents=True, exist_ok=True)
+    with YoutubeDL(opts) as ydl:
+        info = ydl.extract_info(url, download=False)
+        target = Path(ydl.prepare_filename(info))
+        if target.exists():
+            return target, "already in library"
+        ydl.download([url])
+        return target, "saved"