Each mix rebuild now also finds songs that aren't in the library: the user's Listenbrainz recommendations they've never played, plus an LB Radio prompt per mix when a Listenbrainz token is configured. Each candidate goes to the mix whose genre profile it fits best and is skipped if it's already in the library or was played recently. discover/ is a new React app to listen to the mixes: library songs stream from Subsonic and suggested songs are found on YouTube with yt-dlp, both proxied through playlistd with Range support for seeking. Suggestions can be liked (kept in a "Liked new songs" list) or hidden. - discover: candidate gathering, genre fit scoring, library filtering - web: /api/discover routes, Subsonic/YouTube streaming proxy - youtube: yt-dlp search (skipping hour-long results) and audio URLs - mix tags now hold library genre names, for display in the UI - config: listenbrainz.token, discover.ui, discover.ytdlp, discover.format Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_018opPJMJjLWr4RqdG6vuK6p
231 lines
6.4 KiB
Rust
231 lines
6.4 KiB
Rust
mod cluster;
|
|
mod daemon;
|
|
mod discover;
|
|
mod listenbrainz;
|
|
mod mix;
|
|
mod models;
|
|
mod playlist;
|
|
mod subsonic;
|
|
mod track;
|
|
mod web;
|
|
mod youtube;
|
|
|
|
use crate::daemon::{cluster_mixes_daemon, create_playlists_daemon, update_playlists_daemon};
|
|
use crate::models::{
|
|
ClusterMixRule, CreateTrackedPlaylist, PartialClusterMixRule, PartialCreateTrackedPlaylist,
|
|
PartialTrackedPlaylist, TrackedPlaylist,
|
|
};
|
|
use crate::subsonic::{Subsonic, SubsonicBuilder};
|
|
use config::Config;
|
|
use rocket::serde::json::{json, Json};
|
|
use rocket::{get, post, routes, serde::json::Value as JsonValue, State};
|
|
use serde::{Deserialize, Serialize};
|
|
use sqlx::postgres::PgPool;
|
|
use std::sync::{Arc, OnceLock};
|
|
|
|
pub static CONFIG: OnceLock<Config> = OnceLock::new();
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
CONFIG
|
|
.set(
|
|
Config::builder()
|
|
.add_source(config::File::with_name("playlistd").required(false))
|
|
.add_source(config::Environment::default().separator("_"))
|
|
.build()
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
|
|
let database = PgPool::connect(
|
|
CONFIG
|
|
.get()
|
|
.unwrap()
|
|
.get::<String>("database.url")?
|
|
.as_str(),
|
|
)
|
|
.await?;
|
|
sqlx::migrate!().run(&database).await?;
|
|
|
|
let media_client = Arc::new(
|
|
SubsonicBuilder::new()
|
|
.base(CONFIG.get().unwrap().get::<String>("subsonic.base")?)
|
|
.username(CONFIG.get().unwrap().get::<String>("subsonic.username")?)
|
|
.password(CONFIG.get().unwrap().get::<String>("subsonic.password")?)
|
|
.build()?,
|
|
);
|
|
|
|
{
|
|
let _media_client = media_client.clone();
|
|
tokio::spawn(async move {
|
|
update_playlists_daemon(_media_client).await.unwrap();
|
|
});
|
|
}
|
|
{
|
|
let _media_client = media_client.clone();
|
|
tokio::spawn(async move {
|
|
create_playlists_daemon(_media_client).await.unwrap();
|
|
});
|
|
}
|
|
{
|
|
let _media_client = media_client.clone();
|
|
tokio::spawn(async move {
|
|
cluster_mixes_daemon(_media_client).await.unwrap();
|
|
});
|
|
}
|
|
|
|
let youtube = youtube::YouTube::new(
|
|
CONFIG
|
|
.get()
|
|
.unwrap()
|
|
.get::<String>("discover.ytdlp")
|
|
.unwrap_or_else(|_| "yt-dlp".to_string()),
|
|
);
|
|
|
|
let mut server = rocket::build()
|
|
.manage(media_client)
|
|
.manage(database)
|
|
.manage(youtube)
|
|
.mount("/api/discover", web::routes())
|
|
.mount(
|
|
"/api/playlist",
|
|
routes![
|
|
create_tracking_playlist,
|
|
add_tracking_playlist,
|
|
all_playlists,
|
|
create_tracking_playlist_rule,
|
|
create_cluster_mix_rule,
|
|
all_cluster_mix_rules,
|
|
],
|
|
);
|
|
|
|
// the discover UI's built files (discover/dist)
|
|
if let Ok(ui) = CONFIG.get().unwrap().get::<String>("discover.ui") {
|
|
server = server.mount("/", rocket::fs::FileServer::from(ui));
|
|
}
|
|
|
|
server.launch().await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct JsonError {
|
|
error: String,
|
|
}
|
|
|
|
impl From<sqlx::Error> for JsonError {
|
|
fn from(value: sqlx::Error) -> Self {
|
|
Self {
|
|
error: value.to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<uuid::Error> for JsonError {
|
|
fn from(value: uuid::Error) -> Self {
|
|
Self {
|
|
error: value.to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
enum Response<T> {
|
|
Success(T),
|
|
Error(JsonError),
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct CreatePlaylist {
|
|
pub playlist_name: String,
|
|
pub playlist_size: i32,
|
|
pub tracking_user: Option<String>,
|
|
pub tracking_type: Option<String>,
|
|
}
|
|
|
|
/// Create a new playlist and attach a tracker
|
|
#[post("/rule", data = "<create_playlist_rule>")]
|
|
async fn create_tracking_playlist_rule(
|
|
pool: &State<PgPool>,
|
|
create_playlist_rule: Json<PartialCreateTrackedPlaylist>,
|
|
) -> Json<Response<CreateTrackedPlaylist>> {
|
|
match create_playlist_rule.record(pool.inner()).await {
|
|
Ok(playlist) => Json(Response::Success(playlist)),
|
|
Err(e) => Json(Response::Error(e.into())),
|
|
}
|
|
}
|
|
|
|
/// Create a new playlist and attach a tracker
|
|
#[post("/create", data = "<create_playlist>")]
|
|
async fn create_tracking_playlist(
|
|
media_client: &State<Arc<Subsonic>>,
|
|
pool: &State<PgPool>,
|
|
create_playlist: Json<CreatePlaylist>,
|
|
) -> Json<Response<TrackedPlaylist>> {
|
|
match media_client
|
|
.create_playlist(create_playlist.playlist_name.clone())
|
|
.await
|
|
{
|
|
Ok(created_playlist) => {
|
|
let partial = PartialTrackedPlaylist {
|
|
playlist_id: created_playlist.id,
|
|
playlist_size: create_playlist.playlist_size,
|
|
tracking_user: create_playlist.tracking_user.clone(),
|
|
tracking_type: create_playlist.tracking_type.clone(),
|
|
};
|
|
|
|
match partial.record(pool.inner()).await {
|
|
Ok(playlist) => Json(Response::Success(playlist)),
|
|
Err(e) => Json(Response::Error(e.into())),
|
|
}
|
|
}
|
|
|
|
Err(_) => Json(Response::Error(JsonError {
|
|
error: "Couldn't create Subsonic playlist".to_string(),
|
|
})),
|
|
}
|
|
}
|
|
|
|
/// Add tracking to an existing playlist
|
|
#[post("/track", data = "<playlist>")]
|
|
async fn add_tracking_playlist(
|
|
pool: &State<PgPool>,
|
|
playlist: Json<PartialTrackedPlaylist>,
|
|
) -> Json<Response<TrackedPlaylist>> {
|
|
match playlist.record(pool.inner()).await {
|
|
Ok(playlist) => Json(Response::Success(playlist)),
|
|
Err(e) => Json(Response::Error(e.into())),
|
|
}
|
|
}
|
|
|
|
/// Get all tracked playlists
|
|
#[get("/")]
|
|
async fn all_playlists(pool: &State<PgPool>) -> JsonValue {
|
|
match TrackedPlaylist::all(pool.inner()).await {
|
|
Ok(playlists) => json!(playlists),
|
|
Err(_) => json!([]),
|
|
}
|
|
}
|
|
|
|
/// Create a rule that maintains genre mixes built from clustering a user's recent listens
|
|
#[post("/mix", data = "<rule>")]
|
|
async fn create_cluster_mix_rule(
|
|
pool: &State<PgPool>,
|
|
rule: Json<PartialClusterMixRule>,
|
|
) -> Json<Response<ClusterMixRule>> {
|
|
match rule.record(pool.inner()).await {
|
|
Ok(rule) => Json(Response::Success(rule)),
|
|
Err(e) => Json(Response::Error(e.into())),
|
|
}
|
|
}
|
|
|
|
/// Get all cluster mix rules
|
|
#[get("/mix")]
|
|
async fn all_cluster_mix_rules(pool: &State<PgPool>) -> JsonValue {
|
|
match ClusterMixRule::all(pool.inner()).await {
|
|
Ok(rules) => json!(rules),
|
|
Err(_) => json!([]),
|
|
}
|
|
}
|