bctui 0.1.0__tar.gz

bctui-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Simon Larsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bctui-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: bctui
+Version: 0.1.0
+Author-email: "Simon J. Larsen" <simonhffh@gmail.com>
+Maintainer-email: "Simon J. Larsen" <simonhffh@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=8.2.7
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pyxdg>=0.28
+Requires-Dist: mpv>=1.0.8
+Dynamic: license-file
+
+bctui
+=====
+
+A simple text-based Bandcamp music player that allows you to stream your music collection.
+
+bctui is built on the new (in beta) [OpenSubsonic API](https://blog.bandcamp.com/2026/07/16/discover-improvements-and-subsonic-implementation/) and uses libmpv for streaming and playback.
+The TUI is implemented in Python using [Textual](https://textual.textualize.io).
+
+![screenshot](https://github.com/user-attachments/assets/9d4825fa-56ae-4a8a-bbfc-10017303f2d5)
+
+## Installation
+
+First make sure `libmpv` is installed. On Debian-based systems you can install it with:
+```sh
+sudo apt install libmpv2
+```
+
+Then clone the repository and install the package, e.g.:
+
+```sh
+git clone https://github.com/SimonLarsen/bctui.git
+cd bctui
+uv run bctui
+```
+
+## Configuration
+
+Create a new configuration file in `$XDG_CONFIG_HOME/bctui/bctui.json` and add your Bandcamp Subsonic username and password:
+
+```sh
+mkdir -p ~/.config/bctui
+cat <<EOF> ~/.config/bctui/bctui.json
+{
+    "username": "XXXXXXXX",
+    "password": "XXXXXXXX"
+}
+EOF
+```
+
+You can obtain your credentials under [Settings > Fan > Subsonic](https://bandcamp.com/settings?pane=fan#subsonic).

bctui-0.1.0/README.md

@@ -0,0 +1,40 @@
+bctui
+=====
+
+A simple text-based Bandcamp music player that allows you to stream your music collection.
+
+bctui is built on the new (in beta) [OpenSubsonic API](https://blog.bandcamp.com/2026/07/16/discover-improvements-and-subsonic-implementation/) and uses libmpv for streaming and playback.
+The TUI is implemented in Python using [Textual](https://textual.textualize.io).
+
+![screenshot](https://github.com/user-attachments/assets/9d4825fa-56ae-4a8a-bbfc-10017303f2d5)
+
+## Installation
+
+First make sure `libmpv` is installed. On Debian-based systems you can install it with:
+```sh
+sudo apt install libmpv2
+```
+
+Then clone the repository and install the package, e.g.:
+
+```sh
+git clone https://github.com/SimonLarsen/bctui.git
+cd bctui
+uv run bctui
+```
+
+## Configuration
+
+Create a new configuration file in `$XDG_CONFIG_HOME/bctui/bctui.json` and add your Bandcamp Subsonic username and password:
+
+```sh
+mkdir -p ~/.config/bctui
+cat <<EOF> ~/.config/bctui/bctui.json
+{
+    "username": "XXXXXXXX",
+    "password": "XXXXXXXX"
+}
+EOF
+```
+
+You can obtain your credentials under [Settings > Fan > Subsonic](https://bandcamp.com/settings?pane=fan#subsonic).

bctui-0.1.0/bctui/__init__.py

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

bctui-0.1.0/bctui/__main__.py

@@ -0,0 +1,5 @@
+def main() -> None:
+    from bctui.app import BCTUIApp
+
+    app = BCTUIApp()
+    app.run()

bctui-0.1.0/bctui/app.py

@@ -0,0 +1,405 @@
+from dataclasses import dataclass
+
+import mpv
+from textual import events, work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.reactive import reactive
+from textual.screen import ModalScreen
+from textual.widgets import Footer, Input, Label, OptionList, ProgressBar
+
+from bctui.cache import load_collection, save_collection
+from bctui.config import Config
+from bctui.renderables import AlbumRow, TrackRow
+from bctui.subsonic import SubsonicClient
+from bctui.types import CollectionEntry, TrackData
+from bctui.widgets import StatusBar, VimOptionList
+
+
+class AlbumList(VimOptionList):
+    DEFAULT_CSS = """
+    AlbumList {
+        width: 0.5fr;
+        height: 1fr;
+        border: round $foreground;
+        &:focus { border: round $primary; }
+    }
+    """
+    collection: reactive[list[CollectionEntry]] = reactive([])
+    playing_uid: reactive[str | None] = reactive(None)
+
+    @dataclass
+    class AlbumSelected(Message):
+        album: CollectionEntry
+
+    def __init__(self):
+        super().__init__()
+        self.border_title = "Collection"
+
+    def _make_row(self, index: int) -> AlbumRow:
+        album = self.collection[index]
+        return AlbumRow(album.artist, album.title, album.uid == self.playing_uid)
+
+    def watch_collection(self, collection: list[CollectionEntry]) -> None:
+        self.clear_options()
+
+        for i in range(len(self.collection)):
+            self.add_option(self._make_row(i))
+
+        self.highlighted = 0
+        self.focus()
+
+    def watch_playing_uid(self, old_uid: str | None, new_uid: str | None) -> None:
+        for i, album in enumerate(self.collection):
+            if album.uid == old_uid or album.uid == new_uid:
+                self.replace_option_prompt_at_index(i, self._make_row(i))
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        index = event.option_index
+        album = self.collection[index]
+        self.post_message(self.AlbumSelected(album))
+
+
+class TrackList(VimOptionList):
+    DEFAULT_CSS = """
+    TrackList {
+        width: 0.5fr;
+        height: 1fr;
+        border: round $foreground;
+        &:focus { border: round $primary; }
+    }
+    """
+    album_uid: str | None = None
+    tracks: reactive[list[TrackData]] = reactive([])
+    playing_uid: reactive[str | None] = reactive(None)
+
+    @dataclass
+    class TrackSelected(Message):
+        album_uid: str
+        tracks: list[TrackData]
+        index: int
+
+    def __init__(self):
+        super().__init__()
+        self.border_title = "N/A - N/A"
+
+    def _make_row(self, index: int) -> TrackRow:
+        track = self.tracks[index]
+        return TrackRow(
+            index,
+            len(self.tracks),
+            track.title,
+            track.duration,
+            track.uid == self.playing_uid,
+        )
+
+    def watch_tracks(self, tracks: list[TrackData]) -> None:
+        self.clear_options()
+
+        for i in range(len(self.tracks)):
+            self.add_option(self._make_row(i))
+
+        self.highlighted = 0
+
+    def watch_playing_uid(self, old_uid: str | None, new_uid: str | None) -> None:
+        for i, track in enumerate(self.tracks):
+            if track.uid == old_uid or track.uid == new_uid:
+                self.replace_option_prompt_at_index(i, self._make_row(i))
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        if self.album_uid is None:
+            return
+        self.post_message(
+            self.TrackSelected(self.album_uid, self.tracks, event.option_index)
+        )
+
+
+class UpdateCollectionModal(ModalScreen):
+    DEFAULT_CSS = """
+    UpdateCollectionModal {
+        align: center middle;
+
+        Vertical {
+            border: round $foreground;
+            width: 30;
+            height: 4;
+            padding: 0 1 0 1;
+
+            Label {
+                text-align: center;
+            }
+        }
+    }
+    """
+
+    def __init__(self, api: SubsonicClient):
+        super().__init__()
+        self._api = api
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("Updating collection...", expand=True)
+            yield ProgressBar(show_bar=True, show_percentage=False, show_eta=False)
+
+    @work
+    async def _fetch_collection(self) -> None:
+        collection = await self._api.get_collection()
+        self.dismiss(collection)
+
+    async def on_show(self) -> None:
+        self._fetch_collection()
+
+
+class SearchModal(ModalScreen):
+    DEFAULT_CSS = """
+    SearchModal {
+        align: center middle;
+
+        Vertical {
+            border: round $foreground;
+            width: 80%;
+            height: 80%;
+        }
+    }
+    """
+
+    def __init__(self, collection: list[CollectionEntry]):
+        super().__init__()
+        self._search_query: str = ""
+        self._matched_indices: list[int] = []
+        self._collection = collection
+
+    def compose(self) -> ComposeResult:
+        container = Vertical(
+            Input(compact=True),
+            VimOptionList(compact=True),
+        )
+        container.border_title = "Search"
+        yield container
+
+    def on_mount(self) -> None:
+        self._update_list()
+        self.query_exactly_one(Input).focus()
+
+    def _update_list(self) -> None:
+        options = []
+        matched_indices = []
+        for i, album in enumerate(self._collection):
+            key = f"{album.artist.lower()} {album.title.lower()}"
+            if self._search_query in key:
+                options.append(AlbumRow(album.artist, album.title))
+                matched_indices.append(i)
+
+        search_list = self.query_exactly_one(VimOptionList)
+        search_list.clear_options()
+        search_list.add_options(options)
+        self._matched_indices = matched_indices
+
+        if len(options) > 0 and search_list.highlighted is None:
+            search_list.highlighted = 0
+
+    def _confirm(self) -> None:
+        search_list = self.query_exactly_one(VimOptionList)
+        index = search_list.highlighted
+        if index is None:
+            self.dismiss(None)
+            return
+        album = self._collection[self._matched_indices[index]]
+        self.dismiss(album.uid)
+
+    def _move_cursor(self, delta: int) -> None:
+        search_list = self.query_exactly_one(VimOptionList)
+        index = search_list.highlighted
+        if index is None:
+            return
+        index += delta
+        search_list.highlighted = index
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        self._search_query = event.value
+        self._update_list()
+
+    def on_key(self, event: events.Key) -> None:
+        if event.key == "escape":
+            self.dismiss(None)
+        elif event.key == "enter":
+            self._confirm()
+            event.stop()
+        elif event.key == "ctrl+p":
+            self._move_cursor(-1)
+        elif event.key == "ctrl+n":
+            self._move_cursor(1)
+
+
+class BCTUIApp(App):
+    CSS_PATH = "style.tcss"
+
+    ENABLE_COMMAND_PALETTE = False
+    AUTO_FOCUS = None
+
+    BINDINGS = [
+        Binding("f2", "search", "Search"),
+        Binding("<", "prev", "Prev"),
+        Binding(">", "next", "Next"),
+        Binding("p", "pause", "Pause"),
+        Binding("h,left", "focus_collection", "Focus collection", show=False),
+        Binding("l,right", "focus_track_list", "Focus tracks", show=False),
+        Binding("U", "update_collection", "Update collection"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._config = Config.load()
+        self._api = SubsonicClient(
+            username=self._config.username, password=self._config.password
+        )
+        self._collection = load_collection()
+        self._mpv = mpv.MPV(
+            force_seekable=True,
+            prefetch_playlist=True,
+        )
+
+        self._mpv.register_event_callback(self._handle_event)
+
+        self._playlist: list[TrackData] = []
+
+    def _handle_event(self, event: mpv.MpvEvent) -> None:
+        if event.event_id.value == mpv.MpvEventID.START_FILE:
+            self._update_track_list_playing()
+
+    def compose(self) -> ComposeResult:
+        with Horizontal():
+            yield AlbumList()
+            yield TrackList()
+        yield StatusBar()
+        yield ProgressBar(
+            total=1.0,
+            show_percentage=False,
+            show_eta=False,
+        )
+        yield Footer(compact=True)
+
+    def on_mount(self) -> None:
+        self.theme = self._config.theme
+
+        self.progress_timer = self.set_interval(1.0, self.update_progress)
+
+        album_list = self.query_exactly_one(AlbumList)
+        album_list.collection = self._collection
+
+    def on_unmount(self) -> None:
+        self._mpv.terminate()
+
+    def _update_track_list_playing(self) -> None:
+        pos = self._mpv.playlist_pos
+        if not isinstance(pos, int) or pos < 0:
+            return
+
+        track = self._playlist[pos]
+
+        track_list = self.query_exactly_one(TrackList)
+        track_list.playing_uid = track.uid
+
+        status_bar = self.query_exactly_one(StatusBar)
+        status_bar.artist = track.artist
+        status_bar.title = track.title
+        status_bar.album = track.album
+
+    async def _update_track_list(self, message: AlbumList.AlbumSelected) -> None:
+        album_data = await self._api.get_album(message.album.uid)
+        track_list = self.query_exactly_one(TrackList)
+        track_list.border_title = f"{message.album.artist} - {message.album.title}"
+        track_list.album_uid = message.album.uid
+        track_list.tracks = list(album_data.songs)
+        self._update_track_list_playing()
+
+    async def on_album_list_album_selected(
+        self, message: AlbumList.AlbumSelected
+    ) -> None:
+        await self._update_track_list(message)
+        self.query_exactly_one(TrackList).focus()
+
+    def on_track_list_track_selected(self, message: TrackList.TrackSelected) -> None:
+        self._mpv.stop(keep_playlist=False)
+        self._mpv.playlist_clear()
+        for track in message.tracks:
+            url = self._api.get_stream_url(track.uid)
+            self._mpv.playlist_append(str(url))
+        self._set_playlist_pos(message.index)
+        self.playing_album_uid = message.album_uid
+
+        album_list = self.query_exactly_one(AlbumList)
+        album_list.playing_uid = message.album_uid
+        self._playlist = message.tracks
+
+    def _set_playlist_pos(self, index: int) -> None:
+        n = self._mpv.playlist_count
+        if not isinstance(n, int) or n < 1:
+            return
+        self._mpv.playlist_pos = min(max(index, 0), n - 1)
+        self._mpv.pause = False
+
+    @work
+    async def action_search(self) -> None:
+        uid = await self.push_screen_wait(SearchModal(self._collection))
+        if uid is None:
+            return
+
+        album_list = self.query_exactly_one(AlbumList)
+        for i, album in enumerate(self._collection):
+            if album.uid == uid:
+                album_list.highlighted = i
+                album_list.action_select()
+                return
+
+    def action_prev(self) -> None:
+        pos = self._mpv.playlist_pos
+        if not isinstance(pos, int) or pos == -1:
+            return
+        self._set_playlist_pos(pos - 1)
+
+    def action_next(self) -> None:
+        pos = self._mpv.playlist_pos
+        if not isinstance(pos, int) or pos == -1:
+            return
+        self._set_playlist_pos(pos + 1)
+
+    def action_pause(self) -> None:
+        self._mpv.pause = not self._mpv.pause
+
+    def action_focus_collection(self) -> None:
+        self.query_exactly_one(AlbumList).focus()
+
+    def action_focus_track_list(self) -> None:
+        self.query_exactly_one(TrackList).focus()
+
+    @work
+    async def action_update_collection(self) -> None:
+        self._collection = await self.push_screen_wait(UpdateCollectionModal(self._api))
+        save_collection(self._collection)
+
+        album_list = self.query_exactly_one(AlbumList)
+        album_list.collection = self._collection
+
+    def update_progress(self) -> None:
+        percent_pos = self._mpv.percent_pos
+        if isinstance(percent_pos, float):
+            progress_bar = self.query_exactly_one(ProgressBar)
+            progress_bar.update(progress=percent_pos / 100)
+
+        status_bar = self.query_exactly_one(StatusBar)
+        time_pos = self._mpv.time_pos
+        if isinstance(time_pos, float):
+            status_bar.position = time_pos
+
+        duration = self._mpv.duration
+        if isinstance(duration, float):
+            status_bar.duration = duration
+
+
+if __name__ == "__main__":
+    app = BCTUIApp()
+    app.run()

bctui-0.1.0/bctui/cache.py

@@ -0,0 +1,51 @@
+import sqlite3
+from collections.abc import Sequence
+from pathlib import Path
+
+import xdg.BaseDirectory
+
+from bctui.types import CollectionEntry
+
+
+def save_collection(collection: Sequence[CollectionEntry]) -> None:
+    cache_dir = Path(xdg.BaseDirectory.save_cache_path("bctui"))
+    con = sqlite3.connect(cache_dir / "collection.db")
+
+    try:
+        cur = con.cursor()
+        cur.execute("DROP TABLE IF EXISTS collection")
+        cur.execute("CREATE TABLE collection(uid, artist, title, year, genre)")
+
+        cur.executemany(
+            "INSERT INTO collection VALUES (:uid, :artist, :title, :year, :genre)",
+            [e.__dict__ for e in collection],
+        )
+    finally:
+        con.commit()
+        con.close()
+
+
+def load_collection() -> list[CollectionEntry]:
+    cache_dir = Path(xdg.BaseDirectory.save_cache_path("bctui"))
+    con = sqlite3.connect(cache_dir / "collection.db")
+
+    try:
+        cur = con.cursor()
+        table_exists = (
+            cur.execute(
+                """
+            SELECT count(*) FROM sqlite_master
+            WHERE type='table' AND name='collection'
+             """
+            ).fetchall()[0][0]
+            == 1
+        )
+
+        if not table_exists:
+            return []
+
+        rows = cur.execute("SELECT * FROM collection").fetchall()
+        return [CollectionEntry(*row) for row in rows]
+    finally:
+        con.commit()
+        con.close()

bctui-0.1.0/bctui/config.py

@@ -0,0 +1,32 @@
+import json
+from dataclasses import dataclass
+
+import xdg.BaseDirectory
+
+DEFAULT_THEME = "catppuccin-mocha"
+
+
+class ConfigNotFoundError(Exception):
+    pass
+
+
+@dataclass
+class Config:
+    username: str
+    password: str
+    theme: str
+
+    @classmethod
+    def load(cls) -> "Config":
+        path = xdg.BaseDirectory.load_first_config("bctui/bctui.json")
+        if path is None:
+            raise ConfigNotFoundError()
+
+        with open(path, "r") as fp:
+            js = json.load(fp)
+
+        return cls(
+            username=js["username"],
+            password=js["password"],
+            theme=js.get("theme", DEFAULT_THEME),
+        )

bctui-0.1.0/bctui/format.py

@@ -0,0 +1,8 @@
+def duration_to_hhmmss(duration: float) -> str:
+    hours = int(duration // 3600)
+    minutes = int((duration % 3600) // 60)
+    seconds = int(duration % 60)
+    if hours > 0:
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+    else:
+        return f"{minutes:02d}:{seconds:02d}"

bctui-0.1.0/bctui/renderables/__init__.py

@@ -0,0 +1,4 @@
+from .album_row import AlbumRow
+from .track_row import TrackRow
+
+__all__ = ["AlbumRow", "TrackRow"]

bctui-0.1.0/bctui/renderables/album_row.py

@@ -0,0 +1,44 @@
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.text import Text
+
+
+class AlbumRow:
+    def __init__(
+        self,
+        artist: str,
+        title: str,
+        playing: bool = False,
+        ratio: float = 0.4,
+    ):
+        self._artist = artist
+        self._title = title
+        self._playing = playing
+        self._ratio = ratio
+
+    def __rich_console__(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> RenderResult:
+        width = options.max_width
+        w1 = round(self._ratio * width)
+        w2 = width - w1 - 1
+
+        t1 = Text(self._artist)
+        t1.truncate(w1, overflow="ellipsis", pad=True)
+
+        t2 = Text(self._title)
+        t2.truncate(w2, overflow="ellipsis", pad=True)
+
+        out = Text(" ").join((t1, t2))
+        if self._playing:
+            out.stylize("reverse")
+        yield out
+
+    @property
+    def playing(self) -> bool:
+        return self._playing
+
+    @playing.setter
+    def playing(self, value: bool) -> None:
+        self._playing = value

bctui-0.1.0/bctui/renderables/track_row.py

@@ -0,0 +1,46 @@
+import math
+
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.text import Text
+
+from bctui.format import duration_to_hhmmss
+
+
+class TrackRow:
+    def __init__(
+        self,
+        track_no: int,
+        num_tracks: int,
+        title: str,
+        duration: float,
+        playing: bool = False,
+    ):
+        self._track_no = track_no
+        self._num_tracks = num_tracks
+        self._title = title
+        self._duration = duration
+        self._playing = playing
+
+    def __rich_console__(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> RenderResult:
+        width = options.max_width
+        no_width = max(math.floor(math.log10(self._num_tracks)) + 2, 2)
+        duration_width = 8 if self._duration >= 3600 else 5
+        track_width = width - no_width - duration_width - 2
+
+        t1 = Text(f"{self._track_no + 1}.")
+        t1.pad_left(no_width - t1.cell_len)
+
+        t2 = Text(self._title)
+        t2.truncate(track_width, overflow="ellipsis", pad=True)
+
+        t3 = Text(duration_to_hhmmss(self._duration))
+        t3.pad_left(duration_width - t3.cell_len)
+
+        out = Text(" ").join((t1, t2, t3))
+        if self._playing:
+            out.stylize("reverse")
+        yield out

bctui-0.1.0/bctui/subsonic.py

@@ -0,0 +1,131 @@
+import hashlib
+import random
+import string
+from typing import Any
+
+import httpx
+
+from bctui.types import AlbumData, CollectionEntry, TrackData
+
+
+class SubsonicConnectionError(Exception):
+    pass
+
+
+class SubsonicCommandFailedError(Exception):
+    pass
+
+
+class SubsonicClient:
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        client_name: str = "bctui",
+        url: str | httpx.URL = "https://bandcamp.com/api/subsonic",
+        version: str = "1.16.1",
+    ):
+        self._username = username
+        self._password = password
+        self._client_name = client_name
+        self._url = httpx.URL(url)
+        self._version = version
+
+    def _get_base_params(self) -> dict[str, str]:
+        salt = "".join(random.choices(string.ascii_letters + string.digits, k=12))
+        token = hashlib.md5((self._password + salt).encode("utf-8")).hexdigest()
+        params = {
+            "u": self._username,
+            "s": salt,
+            "t": token,
+            "c": self._client_name,
+            "v": self._version,
+            "f": "json",
+        }
+        return params
+
+    async def _get(
+        self,
+        endpoint: str,
+        **kwargs,
+    ) -> dict[str, Any]:
+        params = self._get_base_params()
+        params.update(kwargs)
+
+        async with httpx.AsyncClient() as client:
+            res = await client.get(
+                url=self._url.copy_with(path=self._url.path + endpoint),
+                params=params,
+            )
+
+            if res.status_code != 200:
+                raise SubsonicConnectionError(
+                    f"Received status code {res.status_code}."
+                )
+
+        data = res.json()
+        if (
+            "subsonic-response" not in data
+            or data["subsonic-response"].get("status") != "ok"
+        ):
+            raise SubsonicCommandFailedError()
+
+        return data
+
+    async def get_collection(
+        self,
+        albums_per_query: int = 50,
+    ) -> list[CollectionEntry]:
+        albums: list[CollectionEntry] = []
+        offset = 0
+        while True:
+            data = await self._get(
+                "/rest/getAlbumList2",
+                type="newest",
+                size=albums_per_query,
+                offset=offset,
+            )
+            new_albums = data["subsonic-response"]["albumList2"]["album"]
+            if len(new_albums) == 0:
+                break
+
+            for e in new_albums:
+                album = CollectionEntry(
+                    uid=e["id"],
+                    artist=e["artist"],
+                    title=e["name"],
+                    year=e.get("year"),
+                    genre=e.get("genre"),
+                )
+                albums.append(album)
+
+            offset += len(new_albums)
+
+        return albums
+
+    async def get_album(self, uid: str) -> AlbumData:
+        data = await self._get("/rest/getAlbum", id=uid)
+        info = data["subsonic-response"]["album"]
+
+        songs: list[TrackData] = []
+        for e in info["song"]:
+            song = TrackData(
+                uid=e["id"],
+                artist=e["artist"],
+                title=e["title"],
+                album=e["album"],
+                duration=e["duration"],
+                genre=e.get("genre"),
+            )
+            songs.append(song)
+
+        return AlbumData(songs=songs)
+
+    def get_stream_url(self, uid: str) -> httpx.URL:
+        params = self._get_base_params()
+        params.update({"id": uid, "format": "mp3"})
+        url = self._url.copy_with(
+            path=self._url.path + "/rest/stream",
+            params=params,
+        )
+        return url

bctui-0.1.0/bctui/types.py

@@ -0,0 +1,26 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+
+@dataclass
+class CollectionEntry:
+    uid: str
+    artist: str
+    title: str
+    year: int | None
+    genre: str | None
+
+
+@dataclass
+class TrackData:
+    uid: str
+    artist: str
+    title: str
+    album: str
+    duration: int
+    genre: str | None
+
+
+@dataclass
+class AlbumData:
+    songs: Sequence[TrackData]

bctui-0.1.0/bctui/widgets/__init__.py

@@ -0,0 +1,7 @@
+from .status_bar import StatusBar
+from .vim_option_list import VimOptionList
+
+__all__ = [
+    "StatusBar",
+    "VimOptionList",
+]

bctui-0.1.0/bctui/widgets/status_bar.py

@@ -0,0 +1,50 @@
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from bctui.format import duration_to_hhmmss
+
+
+class StatusBar(Horizontal):
+    DEFAULT_CSS = """
+    StatusBar {
+        height: 1;
+    }
+
+    .statusbar--info {
+        width: auto;
+        color: $primary;
+    }
+
+    .statusbar--separator {
+        width: auto;
+    }
+
+    .statusbar--time {
+        width: 1fr;
+        text-align: right;
+    }
+    """
+
+    title: reactive[str | None] = reactive(None, recompose=True)
+    artist: reactive[str | None] = reactive(None, recompose=True)
+    album: reactive[str | None] = reactive(None, recompose=True)
+    position: reactive[float] = reactive(0.0, recompose=True)
+    duration: reactive[float] = reactive(0.0, recompose=True)
+
+    def compose(self) -> ComposeResult:
+        if self.title is not None:
+            yield Static(self.title, classes="statusbar--info")
+
+            if self.artist is not None:
+                yield Static(" by ", classes="statusbar--separator")
+                yield Static(self.artist, classes="statusbar--info")
+
+            if self.album is not None:
+                yield Static(" from ", classes="statusbar--separator")
+                yield Static(self.album, classes="statusbar--info")
+
+        t1 = duration_to_hhmmss(self.position)
+        t2 = duration_to_hhmmss(self.duration)
+        yield Static(f"[{t1}/{t2}]", classes="statusbar--time")

bctui-0.1.0/bctui/widgets/vim_option_list.py

@@ -0,0 +1,22 @@
+from textual.binding import Binding
+from textual.widgets import OptionList
+
+
+class VimOptionList(OptionList):
+    DEFAULT_CSS = """
+    VimOptionList {
+        background: $background;
+        background-tint: $background;
+        scrollbar-size: 1 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding(key="j", action="cursor_down"),
+        Binding(key="k", action="cursor_up"),
+        Binding(key="space", action="select"),
+        Binding(key="g", action="first"),
+        Binding(key="G", action="last"),
+        Binding(key="ctrl+f", action="page_down"),
+        Binding(key="ctrl+b", action="page_up"),
+    ]

bctui-0.1.0/bctui.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: bctui
+Version: 0.1.0
+Author-email: "Simon J. Larsen" <simonhffh@gmail.com>
+Maintainer-email: "Simon J. Larsen" <simonhffh@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=8.2.7
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pyxdg>=0.28
+Requires-Dist: mpv>=1.0.8
+Dynamic: license-file
+
+bctui
+=====
+
+A simple text-based Bandcamp music player that allows you to stream your music collection.
+
+bctui is built on the new (in beta) [OpenSubsonic API](https://blog.bandcamp.com/2026/07/16/discover-improvements-and-subsonic-implementation/) and uses libmpv for streaming and playback.
+The TUI is implemented in Python using [Textual](https://textual.textualize.io).
+
+![screenshot](https://github.com/user-attachments/assets/9d4825fa-56ae-4a8a-bbfc-10017303f2d5)
+
+## Installation
+
+First make sure `libmpv` is installed. On Debian-based systems you can install it with:
+```sh
+sudo apt install libmpv2
+```
+
+Then clone the repository and install the package, e.g.:
+
+```sh
+git clone https://github.com/SimonLarsen/bctui.git
+cd bctui
+uv run bctui
+```
+
+## Configuration
+
+Create a new configuration file in `$XDG_CONFIG_HOME/bctui/bctui.json` and add your Bandcamp Subsonic username and password:
+
+```sh
+mkdir -p ~/.config/bctui
+cat <<EOF> ~/.config/bctui/bctui.json
+{
+    "username": "XXXXXXXX",
+    "password": "XXXXXXXX"
+}
+EOF
+```
+
+You can obtain your credentials under [Settings > Fan > Subsonic](https://bandcamp.com/settings?pane=fan#subsonic).

bctui-0.1.0/bctui.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+bctui/__init__.py
+bctui/__main__.py
+bctui/app.py
+bctui/cache.py
+bctui/config.py
+bctui/format.py
+bctui/subsonic.py
+bctui/types.py
+bctui.egg-info/PKG-INFO
+bctui.egg-info/SOURCES.txt
+bctui.egg-info/dependency_links.txt
+bctui.egg-info/entry_points.txt
+bctui.egg-info/requires.txt
+bctui.egg-info/top_level.txt
+bctui/renderables/__init__.py
+bctui/renderables/album_row.py
+bctui/renderables/track_row.py
+bctui/widgets/__init__.py
+bctui/widgets/status_bar.py
+bctui/widgets/vim_option_list.py

bctui-0.1.0/bctui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bctui-0.1.0/bctui.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bctui = bctui.__main__:main

bctui-0.1.0/bctui.egg-info/requires.txt

@@ -0,0 +1,4 @@
+textual>=8.2.7
+httpx>=0.28.1
+pyxdg>=0.28
+mpv>=1.0.8

bctui-0.1.0/bctui.egg-info/top_level.txt

@@ -0,0 +1 @@
+bctui

bctui-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "bctui"
+dynamic = ["version"]
+dependencies = [
+    "textual>=8.2.7",
+    "httpx>=0.28.1",
+    "pyxdg>=0.28",
+    "mpv>=1.0.8",
+]
+requires-python = ">=3.10"
+authors = [
+    {name = "Simon J. Larsen", email = "simonhffh@gmail.com"},
+]
+maintainers = [
+    {name = "Simon J. Larsen", email = "simonhffh@gmail.com"},
+]
+readme = {file = "README.md", content-type = "text/markdown"}
+license = "MIT"
+
+[project.scripts]
+bctui = "bctui.__main__:main"
+
+[build-system]
+requires = ["setuptools>=82.0.1"]
+
+[tool.setuptools.dynamic]
+version = {attr = "bctui.__version__"}
+
+[tool.basedpyright]
+typeCheckingMode = "standard"
+
+[tool.ruff]
+line-length = 88
+indent-width = 4
+
+[too.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+
+[dependency-groups]
+dev = [
+    "textual-dev>=1.8.0",
+]

bctui-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+