raphson-music-headless 1.0.0__tar.gz

raphson_music_headless-1.0.0/.gitignore

@@ -0,0 +1,2 @@
+config.json
+__pycache__/

raphson_music_headless-1.0.0/CHANGES.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.0.0 2024-11-23
+
+Initial release

raphson_music_headless-1.0.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.3
+Name: raphson_music_headless
+Version: 1.0.0
+Summary: Headless music player server for the Raphson music player
+Project-URL: Homepage, https://codeberg.org/raphson/music-headless
+Project-URL: Issues, https://codeberg.org/raphson/music-headless/issues
+Author-email: Robin Slot <robin@rslot.nl>
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: No Input/Output (Daemon)
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Players
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aiohttp~=3.0
+Requires-Dist: python-vlc~=3.0
+Requires-Dist: raphson-music-client~=1.0
+Description-Content-Type: text/markdown
+
+# Headless playback server for Raphson Music
+
+Client for the Raphson Music server that can be controlled remotely via a simple web interface or [Home Assistant](https://github.com/Sjorsa/ha-rmp/).
+
+## Installation
+
+### Using pipx (recommended)
+
+```
+pipx install raphson-music-headless
+```
+
+Run: `raphson-music-headless`
+
+### Using distribution packages
+ * Debian: `apt install python3-aiohttp python3-vlc`
+ * Fedora: `dnf install python3-aiohttp python3-vlc`
+
+Then install the rest from PyPi: `pip install --user raphson-music-headless`
+
+### From Git
+```
+git clone https://codeberg.org/raphson/music-headless
+cd music-headless
+python3 -m raphson_music_headless
+```
+
+To install:
+```
+pip install --user .
+```
+
+## Usage
+
+1. Create a `config.json` file with credentials (see `config.json.example`).
+2. Run `raphson-music-headless`
+
+## API
+
+See [API.md](./docs/API.md)
+
+## Temporary files
+
+The server writes music to temporary files so VLC can access them. On Linux, the `/tmp` directory is used for this purpose. It is strongly recommended to mount `tmpfs` on `/tmp` to avoid unnecessary writes to your disk, especially when using a Raspberry Pi with sd card.
+
+Check if it is the case by running `mount | grep /tmp`. It should show something like: `tmpfs on /tmp type tmpfs ...`
+
+## Cache size
+
+The `cache_size` setting determines the number of cached tracks for each playlist. These tracks are kept in memory, consuming roughly 3 - 6MB per track including cover image. Say `cache_size` is set to 4 and you use a maximum of 10 playlists, you will need around 200MiB of memory.
+
+## Bugs
+
+When playing mono audio (like news), sound may only be played on the left channel. This appears to be an issue with PipeWire.

raphson_music_headless-1.0.0/README.md

@@ -0,0 +1,54 @@
+# Headless playback server for Raphson Music
+
+Client for the Raphson Music server that can be controlled remotely via a simple web interface or [Home Assistant](https://github.com/Sjorsa/ha-rmp/).
+
+## Installation
+
+### Using pipx (recommended)
+
+```
+pipx install raphson-music-headless
+```
+
+Run: `raphson-music-headless`
+
+### Using distribution packages
+ * Debian: `apt install python3-aiohttp python3-vlc`
+ * Fedora: `dnf install python3-aiohttp python3-vlc`
+
+Then install the rest from PyPi: `pip install --user raphson-music-headless`
+
+### From Git
+```
+git clone https://codeberg.org/raphson/music-headless
+cd music-headless
+python3 -m raphson_music_headless
+```
+
+To install:
+```
+pip install --user .
+```
+
+## Usage
+
+1. Create a `config.json` file with credentials (see `config.json.example`).
+2. Run `raphson-music-headless`
+
+## API
+
+See [API.md](./docs/API.md)
+
+## Temporary files
+
+The server writes music to temporary files so VLC can access them. On Linux, the `/tmp` directory is used for this purpose. It is strongly recommended to mount `tmpfs` on `/tmp` to avoid unnecessary writes to your disk, especially when using a Raspberry Pi with sd card.
+
+Check if it is the case by running `mount | grep /tmp`. It should show something like: `tmpfs on /tmp type tmpfs ...`
+
+## Cache size
+
+The `cache_size` setting determines the number of cached tracks for each playlist. These tracks are kept in memory, consuming roughly 3 - 6MB per track including cover image. Say `cache_size` is set to 4 and you use a maximum of 10 playlists, you will need around 200MiB of memory.
+
+## Bugs
+
+When playing mono audio (like news), sound may only be played on the left channel. This appears to be an issue with PipeWire.

raphson_music_headless-1.0.0/config.example.json

@@ -0,0 +1,9 @@
+{
+    "host": "127.0.0.1",
+    "port": 8181,
+    "server": "https://music.raphson.nl",
+    "token": "",
+    "default_playlists": [],
+    "cache_size": 4,
+    "news": true
+}

raphson_music_headless-1.0.0/deploy-pypi.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -e
+rm -rf dist
+python3 -m build
+python3 -m twine upload dist/*

raphson_music_headless-1.0.0/docs/API.md

@@ -0,0 +1,82 @@
+# API
+
+## GET `/`
+
+Basic web UI
+
+## GET `/state`
+
+```json
+{
+  "playlists": {
+    "all": ["CB", "DK", "JK", "JM", "MA"], // List of all playlist names
+    "enabled": ["CB", "JK"] // List of enabled playlist names
+  },
+  "player": {
+    "has_media": true, // True when paused or playing, false when stopped.
+    "is_playing": true, // True when playing, false when paused or stopped
+    "position": 15, // Current playback position (-1 when stopped)
+    "duration": 207, // Total track duration as reported by VLC (-1 when stopped)
+    "volume": 100 // VLC volume (0-100, -1 when stopped, 0 at initial startup)
+  },
+  "currently_playing": { // May be null, if no media is present or if playing a virtual track like news
+    "path": "JK/25. Resist and Bite.mp3",
+    "duration": 207, // Duration as reported by the server. For seek bars, use the duration in the player section instead.
+    "title": "Resist And Bite", // May be null
+    "album": "War And Victory - Best Of...Sabaton", // May be null
+    "album_artist": "Sabaton", // May be null
+    "year": 2016, // May be null
+    "artists": [ // May be empty, but never null
+      "Sabaton"
+    ]
+  }
+}
+```
+
+## GET `/image`
+
+Album cover image for currently playing track. Responds with status code 400 if no track is playing.
+
+## GET `/list_tracks?playlist=<playlist>`
+
+List of tracks in a playlist. Directly returns the response from the music player endpoint: `/tracks/filter?playlist=<playlist>`
+
+## POST `/stop`
+
+Stop music, if currently playing. Nothing happens if no music is playing.
+
+## POST `/pause`
+
+Pauses music. Nothing happens if music is already paused or no music is playing.
+
+## POST `/play`
+
+If music is paused, playback is resumed. If no music was playing, a new track is loaded and started. If no playlists are enabled, nothing happens.
+
+## POST `/next`
+
+A new track is loaded from the next playlist, and started. If no playlists are enabled, nothing happens.
+
+### POST `/play_news`
+
+The latest available news is downloaded and played immediately, even if hourly news is disabled.
+
+### POST `/seek`
+
+Seek to position in seconds, provided as an integer in the request body.
+
+### POST `/volume`
+
+Set player volume. Post body should be set to an integer 0-100.
+
+## POST `/playlists`
+
+Set enabled playlists. Post body should be a json array of playlist names.
+
+## POST `/enqueue`
+
+Add track to queue. Post body should contain a track path.
+
+## POST `/play_track`
+
+Load a specific track and play it immediately. Post body should contain a track path.

raphson_music_headless-1.0.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "raphson_music_headless"
+version = "1.0.0"
+authors = [
+    { name = "Robin Slot", email = "robin@rslot.nl" },
+]
+description = "Headless music player server for the Raphson music player"
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: No Input/Output (Daemon)",
+    "Framework :: AsyncIO",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Sound/Audio :: Players",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiohttp~=3.0",
+    "raphson_music_client~=1.0",
+    "python-vlc~=3.0"
+]
+
+[project.scripts]
+raphson-music-headless = "raphson_music_headless.__main__:main"
+
+[project.urls]
+Homepage = "https://codeberg.org/raphson/music-headless"
+Issues = "https://codeberg.org/raphson/music-headless/issues"
+
+[tool.basedpyright]
+include = ["raphson_music_headless"]
+reportUnusedCallResult = false
+reportAny = false

raphson_music_headless-1.0.0/raphson_music_headless/__main__.py

@@ -0,0 +1,11 @@
+import logging
+from pathlib import Path
+
+from .config import Config
+from .server import App
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    config = Config.load(Path('config.json'))
+    app = App(config)
+    app.start(config)

raphson_music_headless-1.0.0/raphson_music_headless/config.py

@@ -0,0 +1,23 @@
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Self
+
+
+@dataclass
+class Config:
+    host: str
+    port: int
+    server: str
+    token: str
+    default_playlists: list[str]
+    cache_size: int
+    news: bool
+
+    @classmethod
+    def load(cls, path: Path) -> Self:
+        with open(path, 'r') as config_file:
+            config = json.load(config_file)
+
+        return cls(config['host'], config['port'], config['server'], config['token'], config['default_playlists'], config['cache_size'], config['news'])

raphson_music_headless-1.0.0/raphson_music_headless/downloader.py

@@ -0,0 +1,132 @@
+import asyncio
+import logging
+import time
+import traceback
+from collections import deque
+from datetime import datetime
+
+from raphson_music_client import DownloadedTrack, Playlist, RaphsonMusicClient
+from requests import RequestException
+
+from .config import Config
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Downloader:
+    client: RaphsonMusicClient
+    cache: dict[str, deque[DownloadedTrack]] = {}
+    queue: list[DownloadedTrack] = []
+    all_playlists: dict[str, Playlist] = {}
+    previous_playlist: str | None = None
+    enabled_playlists: list[str]
+    cache_size: int
+    news: DownloadedTrack | None = None
+    last_news_update: int = 0
+
+    def __init__(self, client: RaphsonMusicClient, config: Config):
+        self.client = client
+        self.enabled_playlists = list(config.default_playlists)
+        self.cache_size = config.cache_size
+
+    async def setup(self):
+        asyncio.create_task(self._fill_cache_task())
+        asyncio.create_task(self._update_playlists_task())
+
+    async def _update_playlists_task(self):
+        async def update_playlists():
+            self.all_playlists = {playlist.name: playlist for playlist in await self.client.playlists()}
+
+        while True:
+            await asyncio.gather(update_playlists(), asyncio.sleep(300))
+
+    async def _fill_cache_task(self):
+        while True:
+            await asyncio.gather(self.fill_cache(), asyncio.sleep(1))
+
+    async def fill_cache(self):
+        """
+        Ensure cache contains enough downloaded tracks
+        """
+        # Only update news once every 10 minutes to prevent spam of failing requests
+        if time.time() - self.last_news_update > 10*60:
+            if not self.news:
+                # No news, update immediately
+                _LOGGER.info('downloading news')
+                self.last_news_update = int(time.time())
+                self.news = await self.client.get_news()
+                return
+
+            # Update when new news is ready
+            if datetime.now().minute == 10:
+                _LOGGER.info('Downloading news')
+                self.last_news_update = int(time.time())
+                self.news = await self.client.get_news()
+                return
+
+        if len(self.enabled_playlists) == 0:
+            return
+
+        for playlist_name in self.enabled_playlists:
+            if playlist_name in self.cache:
+                if len(self.cache[playlist_name]) >= self.cache_size:
+                    continue
+            else:
+                self.cache[playlist_name] = deque()
+
+            try:
+                track = await self.client.choose_track(playlist_name)
+                _LOGGER.info('Downloading track: %s', track.path)
+                downloaded = await track.download()
+                self.cache[playlist_name].append(downloaded)
+            except RequestException:
+                _LOGGER.warning('Failed to download track for playlist %s', playlist_name)
+                traceback.print_exc()
+                time.sleep(1)
+
+    def select_playlist(self) -> str | None:
+        """
+        Choose a playlist to play a track from.
+        """
+        if len(self.enabled_playlists) == 0:
+            _LOGGER.warning('No playlists enabled!')
+            return None
+
+        if self.previous_playlist:
+            try:
+                cur_index = self.enabled_playlists.index(self.previous_playlist)
+                self.previous_playlist = self.enabled_playlists[(cur_index + 1) % len(self.enabled_playlists)]
+            except ValueError:  # not in list
+                self.previous_playlist = self.enabled_playlists[0]
+        else:
+            self.previous_playlist = self.enabled_playlists[0]
+
+        return self.previous_playlist
+
+    async def enqueue(self, track_path: str, front: bool = False) -> None:
+        track = await self.client.get_track(track_path)
+        download = await track.download()
+        if front:
+            self.queue.insert(0, download)
+        else:
+            self.queue.append(download)
+
+    async def enqueue_news(self) -> None:
+        if self.news:
+            self.queue.append(self.news)
+
+    def get_track(self) -> DownloadedTrack | None:
+        """
+        Get the next track to play
+        """
+        if self.queue:
+            return self.queue.pop(0)
+
+        playlist = self.select_playlist()
+        if playlist is None:
+            return None
+
+        if playlist not in self.cache or len(self.cache[playlist]) == 0:
+            return None
+
+        return self.cache[playlist].popleft()

raphson_music_headless-1.0.0/raphson_music_headless/index.html

@@ -0,0 +1,177 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>Raphson Playback Server - Web UI</title>
+        <script>
+            document.addEventListener('DOMContentLoaded', () => {
+                document.getElementById('button-play').addEventListener('click', () => {
+                    fetch('/play', {method: 'POST'})
+                });
+                document.getElementById('button-pause').addEventListener('click', () => {
+                    fetch('/pause', {method: 'POST'})
+                });
+                document.getElementById('button-next').addEventListener('click', () => {
+                    fetch('/next', {method: 'POST'})
+                });
+                document.getElementById('button-stop').addEventListener('click', () => {
+                    fetch('/stop', {method: 'POST'})
+                });
+                document.getElementById('button-news').addEventListener('click', () => {
+                    fetch('/play_news', {method: 'POST'})
+                });
+                document.getElementById('button-seek').addEventListener('click', () => {
+                    fetch('/seek', {method: 'POST', body: parseInt(document.getElementById('position').textContent) + 30});
+                });
+
+                setInterval(async () => {
+                    const response = await fetch('/state');
+                    const state = await response.json();
+                    const player = state.player;
+
+                    document.getElementById('has-media').textContent = player.has_media;
+                    document.getElementById('is-playing').textContent = player.is_playing;
+                    document.getElementById('position').textContent = player.position;
+                    document.getElementById('duration').textContent = player.duration;
+                    document.getElementById('volume').textContent = player.volume;
+                    document.getElementById('track-path').textContent = state.currently_playing ? state.currently_playing.path : '';
+                    document.getElementById('track-title').textContent = state.currently_playing ? state.currently_playing.title : '';
+                    document.getElementById('track-artists').textContent = state.currently_playing && state.currently_playing.artists ? state.currently_playing.artists.join(', ') : '';
+                    document.getElementById('track-album').textContent = state.currently_playing ? state.currently_playing.album : '';
+                    document.getElementById('track-album-artist').textContent = state.currently_playing ? state.currently_playing.album_artist : '';
+                    document.getElementById('track-year').textContent = state.currently_playing ? state.currently_playing.year: '';
+
+                    // add redundant parameter to make the browser perform the request again when the path is changed
+                    if (state.currently_playing) {
+                        document.getElementById('album-cover').src = `/image#cache_bust` + encodeURIComponent(state.currently_playing.path);
+                    } else {
+                        document.getElementById('album-cover').src = "";
+                    }
+                }, 1000);
+
+                setInterval(async () => {
+                    const response = await fetch('/lyrics');
+                    const lyrics = await response.text();
+                    document.getElementById('lyrics').textContent = lyrics;
+                }, 2000);
+
+                document.getElementById('get-playlists').addEventListener('click', async () => {
+                    const response = await fetch('/state');
+                    const state = await response.json();
+                    const playlists = state.playlists;
+
+                    for (playlist of playlists.all) {
+                        const input = document.createElement('input');
+                        input.type = 'checkbox';
+                        input.name = playlist
+                        input.id = 'checkbox-' + playlist.replaceAll(' ', '-');
+                        input.checked = playlists.enabled.indexOf(playlist) !== -1;
+                        input.classList.add('playlist-checkbox');
+
+                        const label = document.createElement('label');
+                        label.htmlFor = 'checkbox-' + playlist.replaceAll(' ', '-');;
+                        label.textContent = playlist;
+
+                        const br = document.createElement('br');
+
+                        document.getElementById('playlist-checkboxes').append(input, label, br);
+                    }
+
+                    document.getElementById('save-playlists').removeAttribute('disabled');
+                    document.getElementById('get-playlists').setAttribute('disabled', '');
+                });
+
+                document.getElementById('save-playlists').addEventListener('click', async () => {
+                    const playlists = []
+                    for (checkbox of document.getElementsByClassName('playlist-checkbox')) {
+                        if (checkbox.checked) {
+                            playlists.push(checkbox.name);
+                        }
+                    }
+                    await fetch('/playlists', {method: 'POST', body: JSON.stringify(playlists)});
+                    document.getElementById('save-playlists').setAttribute('disabled', '');
+                    document.getElementById('get-playlists').removeAttribute('disabled');
+                    document.getElementById('playlist-checkboxes').replaceChildren();
+                });
+            });
+        </script>
+    </head>
+
+    <body>
+        <h3>Controls</h3>
+        <button id="button-play">Play</button>
+        <button id="button-pause">Pause</button>
+        <button id="button-next">Next</button>
+        <button id="button-stop">Stop</button>
+        <button id="button-news">News</button>
+        <button id="button-seek">Seek +30s</button>
+        <h3>Info (updated every second)</h3>
+        <table>
+            <tr>
+                <th colspan="2">Player</th>
+            </tr>
+            <tr>
+                <td>Has media</td>
+                <td id="has-media"></td>
+            </tr>
+            <tr>
+                <td>Is playing</td>
+                <td id="is-playing"></td>
+            </tr>
+            <tr>
+                <td>Position</td>
+                <td id="position"></td>
+            </tr>
+            <tr>
+                <td>Duration</td>
+                <td id="duration"></td>
+            </tr>
+            <tr>
+                <td>Volume</td>
+                <td id="volume"></td>
+            </tr>
+            <tr>
+                <th colspan="2">Track</th>
+            </tr>
+            <tr>
+                <td>Path</td>
+                <td id="track-path"></td>
+            </tr>
+            <tr>
+                <td>Title</td>
+                <td id="track-title"></td>
+            </tr>
+            <tr>
+                <td>Artists</td>
+                <td id="track-artists"></td>
+            </tr>
+            <tr>
+                <td>Album</td>
+                <td id="track-album"></td>
+            </tr>
+            <tr>
+                <td>Album artist</td>
+                <td id="track-album-artist"></td>
+            </tr>
+            <tr>
+                <td>Year</td>
+                <td id="track-year"></td>
+            </tr>
+        </table>
+        <h3>Playlists</h3>
+        <button id="get-playlists">Get playlists</button>
+        <div>
+            <div id="playlist-checkboxes">
+
+            </div>
+            <button id="save-playlists" disabled>Save playlists</button>
+        </div>
+
+        <h3>Lyrics</h3>
+        <div id="lyrics" style="white-space: pre-line"></div>
+
+        <h3>Album cover</h3>
+        <img src="" width="1200" style="max-width: 100%;" id="album-cover">
+    </body>
+
+</html>

raphson_music_headless-1.0.0/raphson_music_headless/player.py

@@ -0,0 +1,178 @@
+import asyncio
+import logging
+import time
+import traceback
+from collections.abc import Coroutine
+from datetime import datetime
+from tempfile import NamedTemporaryFile
+from typing import TYPE_CHECKING, cast
+
+from raphson_music_client.track import DownloadedTrack
+import vlc
+from raphson_music_client import RaphsonMusicClient
+from requests import RequestException
+
+from .config import Config
+from .downloader import Downloader
+
+if TYPE_CHECKING:
+    from tempfile import \
+        _TemporaryFileWrapper  # pyright: ignore[reportPrivateUsage]
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AudioPlayer():
+    temp_file: '_TemporaryFileWrapper[bytes] | None' = None
+    downloader: 'Downloader'
+    client: RaphsonMusicClient
+    currently_playing: DownloadedTrack | None = None
+    vlc_instance: vlc.Instance
+    vlc_player: vlc.MediaPlayer
+    vlc_events: vlc.EventManager
+    start_timestamp: int = 0
+    news: bool
+    last_news: int
+
+    def __init__(self,
+                 client: RaphsonMusicClient,
+                 downloader: 'Downloader',
+                 config: Config):
+        self.client = client
+        self.downloader = downloader
+        self.news = config.news
+        self.last_news = int(time.time())  # do not queue news right after starting
+
+        self.vlc_instance = vlc.Instance('--file-caching=0')
+        self.vlc_player = self.vlc_instance.media_player_new()
+        self.vlc_events = self.vlc_player.event_manager()
+
+    async def setup(self):
+        asyncio.create_task(self._now_playing_submitter())
+        self.vlc_events.event_attach(vlc.EventType.MediaPlayerEndReached, self.on_media_end, asyncio.get_running_loop())
+
+    async def on_media_end_async(self) -> None:
+        tasks: list[Coroutine[None, None, None]] = []
+        # save current info before it is replaced by the next track
+        if self.currently_playing and self.currently_playing.track:
+            path = self.currently_playing.track.path
+            start_timestamp = self.start_timestamp
+            tasks.append(self.client.submit_played(path, start_timestamp))
+        tasks.append(self.next(retry=True))
+        await asyncio.gather(*tasks)
+
+    def on_media_end(self, event, loop: asyncio.AbstractEventLoop):
+        _LOGGER.info('Media ended, play next')
+        async def create_task():
+            await loop.create_task(self.on_media_end_async())
+        asyncio.run_coroutine_threadsafe(create_task(), loop)
+
+    def stop(self):
+        try:
+            self.vlc_player.stop()
+            self.vlc_player.set_media(None)
+            self.currently_playing = None
+        finally:
+            if self.temp_file:
+                self.temp_file.close()
+
+    def pause(self):
+        self.vlc_player.set_pause(True)
+        asyncio.create_task(self._submit_now_playing())
+
+    async def play(self):
+        if self.has_media():
+            self.vlc_player.play()
+            asyncio.create_task(self._submit_now_playing())
+        else:
+            await self.next()
+
+    async def next(self, retry: bool = False, force_news: bool = False) -> None:
+        if force_news:
+            await self.downloader.enqueue_news()
+        elif self.news:
+            minute = datetime.now().minute
+            # a few minutes past the hour and last news played more than 30 minutes ago?
+            if minute > 11 and minute < 20 and time.time() - self.last_news > 30*60:
+                # Attempt to download news. If it fails, next retry news won't be
+                # downloaded again because last_news is updated
+                self.last_news = int(time.time())
+                try:
+                    await self.downloader.enqueue_news()
+                except:
+                    traceback.print_exc()
+
+        download = self.downloader.get_track()
+
+        if not download:
+            _LOGGER.warning('No cached track available')
+            if retry:
+                _LOGGER.info('Retry enabled, going to try again')
+                time.sleep(5)
+                self.next(retry)
+            return
+
+        self.currently_playing = download
+        self.start_timestamp = int(time.time())
+        if download.track:
+            _LOGGER.info('Playing track:', download.track.path)
+        else:
+            _LOGGER.info('Playing virtual track')
+        temp_file = NamedTemporaryFile('wb', prefix='rmp-playback-server-')
+
+        try:
+            temp_file.truncate(0)
+            temp_file.write(download.audio)
+
+            media = self.vlc_instance.media_new(temp_file.name)
+            self.vlc_player.set_media(media)
+            self.vlc_player.play()
+        finally:
+            # Remove old temp file
+            if self.temp_file:
+                self.temp_file.close()
+            # Store current temp file so it can be removed later
+            self.temp_file = temp_file
+
+        asyncio.create_task(self._submit_now_playing())
+
+    def has_media(self) -> bool:
+        return self.vlc_player.get_media() is not None
+
+    def is_playing(self) -> bool:
+        return cast(int, self.vlc_player.is_playing()) == 1
+
+    def position(self) -> int:
+        return cast(int, self.vlc_player.get_time()) // 1000
+
+    def duration(self) -> int:
+        return cast(int, self.vlc_player.get_length()) // 1000
+
+    def seek(self, position: int):
+        _LOGGER.info('Seek to:', position)
+        self.vlc_player.set_time(position * 1000)
+
+    def volume(self) -> int:
+        return self.vlc_player.audio_get_volume()
+
+    def set_volume(self, volume: int) -> None:
+        self.vlc_player.audio_set_volume(volume)
+
+    async def _submit_now_playing(self):
+        if self.has_media() and self.currently_playing and self.currently_playing.track:
+            await self.client.submit_now_playing(self.currently_playing.track.path,
+                                        self.position(),
+                                        not self.is_playing())
+
+    async def _now_playing_submitter(self):
+        while True:
+            try:
+                await self._submit_now_playing()
+            except RequestException:
+                _LOGGER.warning('Failed to submit now playing info')
+
+            if self.is_playing():
+                await asyncio.sleep(10)
+            else:
+                await asyncio.sleep(60)

raphson_music_headless-1.0.0/raphson_music_headless/server.py

@@ -0,0 +1,180 @@
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any, cast
+
+from aiohttp import web
+from aiohttp.web_app import Application
+from raphson_music_client import RaphsonMusicClient
+from raphson_music_client.playlist import Playlist
+
+from .config import Config
+from .downloader import Downloader
+from .player import AudioPlayer
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class App:
+    config: Config
+    client: RaphsonMusicClient
+    player: AudioPlayer
+    downloader: Downloader
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.client = RaphsonMusicClient()
+        self.downloader = Downloader(self.client, config)
+        self.player = AudioPlayer(self.client, self.downloader, config)
+
+    async def _root(self, _request: web.Request) -> web.StreamResponse:
+        return web.FileResponse(Path(__file__).parent / "index.html")
+
+    async def _state(self, _request: web.Request) -> web.StreamResponse:
+        data: dict[str, Any] = {
+            "playlists": {
+                "all": list(self.downloader.all_playlists.keys()),
+                "enabled": self.downloader.enabled_playlists,
+            },
+            "player": {
+                "has_media": self.player.has_media(),
+                "is_playing": self.player.is_playing(),
+                "position": self.player.position(),
+                "duration": self.player.duration(),
+                "volume": self.player.volume(),
+            },
+        }
+        if self.player.currently_playing and self.player.currently_playing.track:
+            track = self.player.currently_playing.track
+            data["currently_playing"] = {
+                "path": track.path,
+                "duration": track.duration,
+                "title": track.title,
+                "album": track.album,
+                "album_artist": track.album_artist,
+                "year": track.year,
+                "artists": track.artists,
+            }
+        else:
+            data["currently_playing"] = None
+
+        return web.json_response(data)
+
+    async def _image(self, _request: web.Request) -> web.StreamResponse:
+        if self.player.currently_playing:
+            return web.Response(
+                body=self.player.currently_playing.image,
+                status=200,
+                content_type="image/webp",
+            )
+
+        return web.Response(status=404)
+
+    async def _lyrics(self, _request: web.Request) -> web.StreamResponse:
+        if self.player.currently_playing:
+            lyrics = self.player.currently_playing.lyrics_text
+            if lyrics:
+                return web.Response(
+                    body=self.player.currently_playing.lyrics_text,
+                    status=200,
+                    content_type="text/plain",
+                )
+
+        return web.Response(status=204)
+
+    async def _list_tracks(self, request: web.Request) -> web.StreamResponse:
+        playlist = request.query["playlist"]
+        return web.Response(
+            body=await self.client.list_tracks_response(playlist),
+            status=200,
+            content_type="application/json",
+        )
+
+    async def _stop(self, _request: web.Request) -> web.StreamResponse:
+        self.player.stop()
+        return web.Response(status=204)
+
+    async def _pause(self, _request: web.Request) -> web.StreamResponse:
+        self.player.pause()
+        return web.Response(status=204)
+
+    async def _play(self, _request: web.Request) -> web.StreamResponse:
+        await self.player.play()
+        return web.Response(status=204)
+
+    async def _next(self, _request: web.Request) -> web.StreamResponse:
+        await self.player.next()
+        return web.Response(status=204)
+
+    async def _play_news(self, _request: web.Request) -> web.StreamResponse:
+        await self.player.next(force_news=True)
+        return web.Response(status=204)
+
+    async def _seek(self, request: web.Request) -> web.StreamResponse:
+        position = int(await request.text())
+        self.player.seek(position)
+        return web.Response(status=204)
+
+    async def _volume(self, request: web.Request) -> web.StreamResponse:
+        volume = int(await request.text())
+        self.player.set_volume(volume)
+        return web.Response(status=204)
+
+    async def _playlists(self, request: web.Request) -> web.StreamResponse:
+        playlists = cast(list[str], await request.json())
+        assert isinstance(playlists, list)
+        for playlist in playlists:
+            assert isinstance(playlist, str)
+            assert playlist in self.downloader.all_playlists
+        _LOGGER.info("Changed enabled playlists:", playlists)
+        self.downloader.enabled_playlists = playlists
+        return web.Response(status=204)
+
+    async def _enqueue(self, request: web.Request) -> web.StreamResponse:
+        await self.downloader.enqueue(await request.text())
+        return web.Response(status=204)
+
+    async def _play_track(self, request: web.Request) -> web.StreamResponse:
+        await self.downloader.enqueue(await request.text(), front=True)
+        await self.player.next()
+        return web.Response(status=204)
+
+    async def setup(self, _app: Application):
+        await self.client.setup(
+            base_url=self.config.server,
+            user_agent="Raphson-Music-Headless",
+            token=self.config.token,
+        )
+        await self.downloader.setup()
+        await self.player.setup()
+
+    async def cleanup(self, _app: Application) -> None:
+        _LOGGER.info("Stopping")
+        await self.client.close()
+        self.player.stop()
+
+    def start(self, config: Config):
+        routes = [
+            web.get("/", self._root),
+            web.get("/state", self._state),
+            web.get("/image", self._image),
+            web.get("/lyrics", self._lyrics),
+            web.get("/list_tracks", self._list_tracks),
+            web.post("/stop", self._stop),
+            web.post("/pause", self._pause),
+            web.post("/play", self._play),
+            web.post("/next", self._next),
+            web.post("/play_news", self._play_news),
+            web.post("/seek", self._seek),
+            web.post("/volume", self._volume),
+            web.post("/playlists", self._playlists),
+            web.post("/enqueue", self._enqueue),
+            web.post("/play_track", self._play_track),
+        ]
+
+        app = web.Application()
+        app.add_routes(routes)
+        app.on_startup.append(self.setup)
+        app.on_cleanup.append(self.cleanup)
+
+        web.run_app(app, host=config.host, port=config.port)