//! The playground site: `airplay serve [--addr 127.0.0.1:8790] [--prefix /airplay]`. //! //! {prefix}/ the page (src/web/index.html) //! {prefix}/api/meta latest forecast run, horizons, channels, backtest scores //! {prefix}/api/rank?h=4 every artist's forecast for one horizon //! {prefix}/api/artist?id= one artist: profile, 51 weeks of plays per channel, forecasts, chart runs //! {prefix}/api/whatif?id=&h=&entry=&t40=&air= //! re-run the model for one artist with a changed chart situation //! //! Rankings are read from the forecasts table (`airplay model rank`); the what-if models are //! fitted in the background at start and again whenever a newer forecast run appears. use crate::model::adds::{set_chart, AddModel, Rot, CHART_IDX_CHANNEL}; use crate::model::common::{thresholds, Direct, Rng}; use crate::model::features::{self, P}; use crate::model::glm; use crate::model::panel::{Panel, C, CHANNELS}; use crate::model::rank::VERSION; use anyhow::Result; use rusqlite::{params, Connection, OpenFlags, OptionalExtension}; use serde_json::{json, Value}; use std::collections::HashMap; use std::sync::{Arc, RwLock}; use tiny_http::{Header, Method, Response, Server}; const PAGE: &str = include_str!("web/index.html"); const MAX_H: usize = 12; /// Window lengths offered (weeks after the release within which DR must add the song). const WINDOWS: [usize; 6] = [2, 4, 6, 8, 10, 12]; /// Release weeks shown in the best-week calendar. const CALENDAR: usize = 26; /// "If the artist releases a new song in week t0+h+1, will DR add it within `win` weeks?": /// (per channel, any station, any station if placed on NMF Denmark, P(NMF)), blended over the /// new song's NMF placement by how often the artist's releases were placed. None = too soon after /// the artist's last release (the model only learned from releases with a 6-week gap). fn new_song(m: &Models, a: usize, h: usize, win: usize, nmf: Option) -> Option<([f64; C], f64, f64, f64)> { use crate::model::adds::{p_nmf, too_soon, Scenario}; let p = &m.panel; let t0 = p.w() - 1; if too_soon(p, a, t0, h) { return None; } let ev = m.events_w.get(&win).unwrap_or(&m.events); let q = match nmf { Some(true) => 1.0, Some(false) => 0.0, None => p_nmf(p, a, t0) }; let (pcn, pan) = ev.predict_at(p, &m.rot, a, t0, h, Scenario::new(true, true).at(h), None); let (pcr, par) = ev.predict_at(p, &m.rot, a, t0, h, Scenario::new(true, false).at(h), None); Some((std::array::from_fn(|c| q * pcn[c] + (1.0 - q) * pcr[c]), q * pan + (1.0 - q) * par, pan, q)) } struct Models { made_at: String, panel: Panel, tau: [u32; C], direct: Vec, // index h - 1 adds: Vec, // index h events: AddModel, /// The release-event model per window length (weeks the add must come within). events_w: HashMap, rot: Rot, index: HashMap, } struct State { db_path: String, prefix: String, models: RwLock>>, rank_cache: RwLock>>, } fn ro(path: &str) -> Result { let c = Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX)?; c.busy_timeout(std::time::Duration::from_secs(10))?; Ok(c) } fn latest_run(c: &Connection) -> Result> { Ok(c.query_row("SELECT max(made_at) FROM forecasts WHERE model_version = ?1", [VERSION], |r| r.get(0)).optional()?.flatten()) } pub fn serve(db_path: &str, args: &[String]) -> Result<()> { let arg = |n: &str| args.iter().position(|a| a == n).and_then(|i| args.get(i + 1)).cloned(); let addr = arg("--addr").unwrap_or_else(|| "127.0.0.1:8790".into()); let prefix = arg("--prefix").unwrap_or_else(|| "/airplay".into()).trim_end_matches('/').to_string(); let state = Arc::new(State { db_path: db_path.into(), prefix, models: RwLock::new(None), rank_cache: RwLock::new(HashMap::new()) }); // Keep the what-if models in step with the latest forecast run. { let state = state.clone(); std::thread::spawn(move || loop { let current = state.models.read().unwrap().as_ref().map(|m| m.made_at.clone()); let latest = ro(&state.db_path).ok().and_then(|c| latest_run(&c).ok().flatten()); if latest.is_some() && latest != current { match fit_models(&state.db_path, latest.clone().unwrap()) { Ok(m) => { *state.models.write().unwrap() = Some(Arc::new(m)); eprintln!("what-if models ready ({})", latest.unwrap()); } Err(e) => eprintln!("what-if models: {e}"), } } std::thread::sleep(std::time::Duration::from_secs(600)); }); } let server = Arc::new(Server::http(&addr).map_err(|e| anyhow::anyhow!("{addr}: {e}"))?); eprintln!("serving on http://{addr}{}/", state.prefix); let workers: Vec<_> = (0..4).map(|_| { let (server, state) = (server.clone(), state.clone()); std::thread::spawn(move || { for req in server.incoming_requests() { let (status, ctype, body) = match handle(&state, req.method(), req.url()) { Ok(r) => r, Err(e) => (500, "application/json", Arc::new(json!({"error": e.to_string()}).to_string())), }; let mut resp = Response::from_data(body.as_bytes().to_vec()).with_status_code(status) .with_header(Header::from_bytes("Content-Type", ctype).unwrap()) .with_header(Header::from_bytes("X-Robots-Tag", "noindex").unwrap()); if status == 301 { resp = resp.with_header(Header::from_bytes("Location", format!("{}/", state.prefix)).unwrap()); } let _ = req.respond(resp); } }) }).collect(); for w in workers { let _ = w.join(); } Ok(()) } fn fit_models(db_path: &str, made_at: String) -> Result { let db = crate::db::Db::open(db_path)?; let panel = Panel::load(&db)?; let tau = thresholds(&panel, panel.w()); let direct = (1..=MAX_H).map(|h| Direct::fit(&panel, h, panel.w() - 1, &tau, false)).collect(); let rot = Rot::new(&panel, &tau); let adds = (0..=MAX_H).map(|h| AddModel::fit(&panel, &rot, h, panel.w() - 1)).collect(); let events = AddModel::fit_events_site(&panel, &rot, panel.w() - 1); let events_w = WINDOWS.iter().map(|&w| (w, AddModel::fit_events_w(&panel, &rot, panel.w() - 1, w))).collect(); let index = panel.artists.iter().enumerate().map(|(i, a)| (a.id.clone(), i)).collect(); Ok(Models { made_at, panel, tau, direct, adds, events, events_w, rot, index }) } fn query(url: &str) -> HashMap { let q = url.split_once('?').map(|x| x.1).unwrap_or(""); q.split('&').filter_map(|kv| { let (k, v) = kv.split_once('=').unwrap_or((kv, "")); Some((decode(k), decode(v))) }).collect() } fn decode(s: &str) -> String { let b = s.as_bytes(); let mut out = Vec::with_capacity(b.len()); let mut i = 0; while i < b.len() { match b[i] { b'+' => out.push(b' '), b'%' if i + 2 < b.len() => { if let Ok(v) = u8::from_str_radix(std::str::from_utf8(&b[i + 1..i + 3]).unwrap_or("zz"), 16) { out.push(v); i += 2; } else { out.push(b'%'); } } c => out.push(c), } i += 1; } String::from_utf8_lossy(&out).into_owned() } type Reply = (u16, &'static str, Arc); fn ok(v: Value) -> Result { Ok((200, "application/json", Arc::new(v.to_string()))) } fn handle(st: &State, method: &Method, url: &str) -> Result { if *method != Method::Get && *method != Method::Head { return Ok((405, "text/plain", Arc::new("GET only".into()))); } let path = url.split('?').next().unwrap_or(""); let Some(rest) = path.strip_prefix(&st.prefix) else { return Ok((404, "text/plain", Arc::new("not found".into()))) }; let q = query(url); match rest { "" => Ok((301, "text/plain", Arc::new(String::new()))), "/" | "/index.html" => Ok((200, "text/html; charset=utf-8", Arc::new(PAGE.to_string()))), "/api/meta" => meta(st), "/api/rank" => rank(st, q.get("h").and_then(|h| h.parse().ok()).unwrap_or(0).min(CALENDAR - 1), q.get("w").and_then(|w| w.parse().ok()).filter(|w| WINDOWS.contains(w)).unwrap_or(8)), "/api/bestweek" => bestweek(st, &q), "/api/artist" => artist(st, q.get("id").map(String::as_str).unwrap_or("")), "/api/whatif" => whatif(st, &q), _ => Ok((404, "text/plain", Arc::new("not found".into()))), } } fn meta(st: &State) -> Result { let c = ro(&st.db_path)?; let Some(made) = latest_run(&c)? else { return ok(json!({"ready": false})) }; let (origin,): (String,) = c.query_row("SELECT origin_week FROM forecasts WHERE made_at = ?1 LIMIT 1", [&made], |r| Ok((r.get(0)?,)))?; let horizons: Vec = c.prepare("SELECT DISTINCT horizon, target_week FROM forecasts WHERE made_at = ?1 ORDER BY horizon")? .query_map([&made], |r| Ok(json!({"h": r.get::<_, i64>(0)?, "week": r.get::<_, String>(1)?})))?.collect::>()?; let run: Option = c.query_row("SELECT max(run_at) FROM backtest_scores", [], |r| r.get(0)).optional()?.flatten(); // The latest score of each model, horizon and metric (the airplay and add backtests run separately). let scores: Vec = match &run { Some(_) => c.prepare("SELECT model, horizon, metric, value FROM backtest_scores b WHERE run_at = (SELECT max(run_at) FROM backtest_scores WHERE model = b.model AND horizon = b.horizon AND metric = b.metric)")? .query_map([], |r| Ok(json!({"model": r.get::<_, String>(0)?, "h": r.get::<_, i64>(1)?, "metric": r.get::<_, String>(2)?, "value": r.get::<_, Option>(3)?})))? .collect::>()?, None => Vec::new(), }; let models = st.models.read().unwrap(); let tau = models.as_ref().map(|m| m.tau.to_vec()); ok(json!({"ready": true, "made_at": made, "origin_week": origin, "model": VERSION, "horizons": horizons, "channels": CHANNELS, "tau": tau, "whatif_ready": models.is_some(), "backtest_run": run, "backtest": scores})) } /// Puts one forecast row into an artist's JSON: airplay ('rotation', 'any'), new adds ('add', /// 'add_any') and the origin week ('now'). fn fold(e: &mut Value, target: &str, ch: &str, prob: Option, mean: Option, lo: Option, hi: Option) { let r3 = |v: Option| json!(v.map(|p| (p * 1000.0).round() / 1000.0)); let r1 = |v: Option| json!(v.map(|m| (m * 10.0).round() / 10.0)); match target { "any" => { e["p_any"] = r3(prob); e["mean"] = r1(mean); e["lo"] = json!(lo); e["hi"] = json!(hi); } "rotation" => { e["p"][ch] = r3(prob); e["plays"][ch] = r1(mean); } "add_any" => { e["add_any"] = r3(prob); } "add" => { e["add"][ch] = r3(prob); } "add_any_rel" => { e["add_any_rel"] = r3(prob); } "add_any_nmf" => { e["add_any_nmf"] = r3(prob); } "p_nmf" => { e["p_nmf"] = r3(prob); } "too_soon" => { e["too_soon"] = json!(true); } "add_rel" => { if !e["add_rel"].is_object() { e["add_rel"] = json!({}); } e["add_rel"][ch] = r3(prob); } "p_release" => { e["p_release"] = r3(prob); } "now" => { e["now"][ch] = json!({"on": prob.unwrap_or(0.0) > 0.5, "plays": mean}); } _ => {} } } /// Bauer plays (NOVA, Radio Soft, The Voice, Pop FM, Radio 100) in the 7 days up to the latest /// one, per artist name key (each credited artist) and station: (plays, songs). fn bauer_week(c: &Connection) -> Result)>>> { let mut out: HashMap)>> = HashMap::new(); let mut st = c.prepare( "SELECT station, artist, title, count(*) FROM plays WHERE source = 'bauer' AND played_at > (SELECT strftime('%Y-%m-%dT%H:%M:%SZ', max(played_at), '-7 days') FROM plays WHERE source = 'bauer') GROUP BY station, artist, title")?; let rows = st.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?, r.get::<_, String>(2)?, r.get::<_, i64>(3)?)))?; for r in rows { let (station, artist, title, n) = r?; let mut parts = vec![artist.to_lowercase()]; for sep in [" feat. ", " feat ", " ft. ", " ft ", " featuring ", " & ", ", ", " x ", " og ", " vs "] { parts = parts.iter().flat_map(|p| p.split(sep).map(str::to_string).collect::>()).collect(); } let mut keys: Vec = parts.iter().map(|p| crate::model::panel::key(p)).collect(); keys.push(crate::model::panel::key(&artist)); keys.sort(); keys.dedup(); for k in keys.into_iter().filter(|k| !k.is_empty()) { let e = out.entry(k).or_default().entry(station.clone()).or_insert((0, Vec::new())); e.0 += n; e.1.push((title.clone(), n)); } } Ok(out) } fn rank(st: &State, h: usize, win: usize) -> Result { let c = ro(&st.db_path)?; let Some(made) = latest_run(&c)? else { return ok(json!({"rows": []})) }; let live = st.models.read().unwrap().clone(); let key = (made.clone(), h, win, live.is_some()); if let Some(hit) = st.rank_cache.read().unwrap().get(&key) { return Ok((200, "application/json", hit.clone())); } let h_db = h.min(MAX_H); let mut names: HashMap = HashMap::new(); for r in c.prepare("SELECT artist_id, name, json_extract(raw, '$.artist.country'), json_extract(raw, '$.artist.type') FROM dr_artists")? .query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?, r.get::<_, Option>(2)?, r.get::<_, Option>(3)?)))? { let (id, n, country, kind) = r?; names.insert(id, (n, country.as_deref() == Some("Danmark"), kind.is_some_and(|k| k != "person"))); } let mut rows: HashMap = HashMap::new(); let mut st_ = c.prepare("SELECT key, target, prob, mean, lo, hi, target_week FROM forecasts WHERE made_at = ?1 AND model_version = ?2 AND ((target IN ('rotation', 'any') AND horizon = ?3) OR (target IN ('add', 'add_any', 'add_rel', 'add_any_rel', 'add_any_nmf', 'p_nmf', 'p_release', 'too_soon') AND horizon = ?4) OR target = 'now')")?; let it = st_.query_map(params![made, VERSION, h_db.max(1) as i64, h_db as i64], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?, r.get::<_, Option>(2)?, r.get::<_, Option>(3)?, r.get::<_, Option>(4)?, r.get::<_, Option>(5)?, r.get::<_, String>(6)?)))?; let mut window = String::new(); for r in it { let (key, target, prob, mean, lo, hi, week) = r?; let Some((id, ch)) = key.split_once(':') else { continue }; let e = rows.entry(id.to_string()).or_insert_with(|| { let (n, dk, group) = names.get(id).cloned().unwrap_or_default(); json!({"id": id, "name": n, "danish": dk, "group": group, "p": {}, "plays": {}, "add": {}, "now": {}}) }); if target == "add_any" && window.is_empty() { window = week; } fold(e, &target, ch, prob, mean, lo, hi); } let bauer = bauer_week(&c)?; for e in rows.values_mut() { let k = crate::model::panel::key(e["name"].as_str().unwrap_or("")); if let Some(b) = bauer.get(&k) { e["bauer"] = json!(b.iter().map(|(s, v)| (s.clone(), v.0)).collect::>()); } } // The new-song numbers: live from the models for any release week and window, else the stored ones (8 weeks). let mut window = window; if let Some(m) = live.as_ref() { window = (m.panel.weeks[m.panel.w() - 1] + chrono::Duration::weeks(h as i64 + 1)).to_string(); for a in 0..m.panel.a() { let Some(e) = rows.get_mut(&m.panel.artists[a].id) else { continue }; match new_song(m, a, h, win, None) { None => { e["too_soon"] = json!(true); e["add_any_rel"] = Value::Null; e["add_rel"] = json!({}); } Some((pc, pa, pan, q)) => { let r3 = |v: f64| (v * 1000.0).round() / 1000.0; e["too_soon"] = json!(false); e["add_any_rel"] = json!(r3(pa)); e["add_any_nmf"] = json!(r3(pan)); e["p_nmf"] = json!(r3(q)); e["add_rel"] = json!(CHANNELS.iter().zip(pc).map(|(c, v)| (c.to_string(), json!(r3(v)))).collect::>()); } } } } let mut out: Vec = rows.into_values().collect(); out.sort_by(|a, b| b["add_any_rel"].as_f64().unwrap_or(-1.0).total_cmp(&a["add_any_rel"].as_f64().unwrap_or(-1.0))); let body = Arc::new(json!({"made_at": made, "h": h, "w": win, "live": live.is_some(), "window_start": window, "rows": out}).to_string()); let mut cache = st.rank_cache.write().unwrap(); cache.retain(|k, _| k.0 == made); cache.insert(key, body.clone()); Ok((200, "application/json", body)) } /// The best week for an artist to release a new song: the next CALENDAR release weeks with the /// chance DR adds it within `w` weeks (any station and per station group), like a fare calendar. fn bestweek(st: &State, q: &HashMap) -> Result { let guard = st.models.read().unwrap(); let Some(m) = guard.as_ref() else { return Ok((503, "application/json", Arc::new(json!({"loading": true}).to_string()))) }; let Some(&a) = m.index.get(q.get("id").map(String::as_str).unwrap_or("")) else { return Ok((404, "application/json", Arc::new(json!({"error": "artist not in the model"}).to_string()))); }; let win = q.get("w").and_then(|w| w.parse().ok()).filter(|w| WINDOWS.contains(w)).unwrap_or(8); let nmf = match q.get("nmf").map(String::as_str) { Some("yes") => Some(true), Some("no") => Some(false), _ => None }; let p = &m.panel; let t0 = p.w() - 1; // Release weeks between `from` and `to` (default: the next 26), at most 53 weeks, from next week on. let first = p.weeks[t0] + chrono::Duration::weeks(1); let date = |k: &str| q.get(k).and_then(|s| chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d").ok()); let wk = |d: chrono::NaiveDate| ((d - first).num_days().div_euclid(7)).max(0) as usize; let h0 = date("from").map(wk).unwrap_or(0); let h1 = date("to").map(wk).unwrap_or(h0 + CALENDAR - 1).max(h0).min(h0 + 52); let groups = [("P3", vec![0usize]), ("P4", (0..C).filter(|&c| crate::model::panel::is_p4(c)).collect()), ("P5", vec![11]), ("P6", vec![12]), ("P8", vec![13])]; let weeks: Vec = (h0..=h1).map(|h| { let start = p.weeks[t0] + chrono::Duration::weeks(h as i64 + 1); let xmas = crate::model::features::christmas(p, t0 + h + 1); match new_song(m, a, h, win, nmf) { None => json!({"h": h, "week": start.to_string(), "too_soon": true, "christmas": xmas}), Some((pc, pa, _, _)) => json!({"h": h, "week": start.to_string(), "too_soon": false, "christmas": xmas, "p": pa, "groups": groups.iter().map(|(n, cs)| (n.to_string(), json!(cs.iter().map(|&c| pc[c]).fold(0.0, f64::max)))).collect::>()}), } }).collect(); let last_release = p.releases[a].as_ref().and_then(|d| d.iter().rev().find(|d| **d <= p.weeks[t0] + chrono::Duration::days(6)).map(|d| d.to_string())); ok(json!({"id": p.artists[a].id, "name": p.artists[a].name, "w": win, "nmf": q.get("nmf"), "p_nmf": crate::model::adds::p_nmf(p, a, t0), "last_release": last_release, "weeks": weeks})) } fn artist(st: &State, id: &str) -> Result { let c = ro(&st.db_path)?; let Some((name, raw)) = c.query_row("SELECT name, raw FROM dr_artists WHERE artist_id = ?1", [id], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))).optional()? else { return Ok((404, "application/json", Arc::new(json!({"error": "unknown artist"}).to_string()))) }; let v: Value = serde_json::from_str(&raw).unwrap_or(Value::Null); let a = &v["artist"]; let image = a["images"][0]["sizes"].as_array().and_then(|s| s.iter().find(|x| x["size"] == "medium")).and_then(|x| x["source"].as_str()).map(str::to_string); let top: Vec = v["mostPlayed"].as_array().into_iter().flatten().take(8) .map(|t| json!({"title": t["title"], "total": t["total"]})).collect(); // Weekly plays per channel, in the panel's weeks when the models are loaded. // Complete weeks only (as in the panel): ended before the first artist page was read. let mut weeks: Vec = c.prepare( "SELECT DISTINCT week_start FROM dr_artist_weeks WHERE date(week_start, '+7 days') <= (SELECT substr(min(fetched_at), 1, 10) FROM dr_artists) ORDER BY week_start")? .query_map([], |r| r.get(0))?.collect::>()?; if let Some(m) = st.models.read().unwrap().as_ref() { weeks = m.panel.weeks.iter().map(|d| d.to_string()).collect(); } let widx: HashMap<&str, usize> = weeks.iter().enumerate().map(|(i, w)| (w.as_str(), i)).collect(); let mut plays: HashMap<&str, Vec> = CHANNELS.iter().map(|c| (*c, vec![0; weeks.len()])).collect(); for r in c.prepare("SELECT week_start, channel, plays FROM dr_artist_weeks WHERE artist_id = ?1")? .query_map([id], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?, r.get::<_, i64>(2)?)))? { let (w, ch, n) = r?; if let (Some(&i), Some(v)) = (widx.get(w.as_str()), plays.get_mut(ch.as_str())) { v[i] = n; } } let mut fc: Vec = Vec::new(); let mut now_out = Value::Null; if let Some(made) = latest_run(&c)? { let mut byh: HashMap = HashMap::new(); let mut now = json!({}); for r in c.prepare("SELECT horizon, target_week, key, prob, mean, lo, hi, target FROM forecasts WHERE made_at = ?1 AND model_version = ?2 AND key LIKE ?3")? .query_map(params![made, VERSION, format!("{id}:%")], |r| Ok((r.get::<_, i64>(0)?, r.get::<_, String>(1)?, r.get::<_, String>(2)?, r.get::<_, Option>(3)?, r.get::<_, Option>(4)?, r.get::<_, Option>(5)?, r.get::<_, Option>(6)?, r.get::<_, String>(7)?)))? { let (h, week, key, prob, mean, lo, hi, target) = r?; let ch = key.split_once(':').map(|x| x.1).unwrap_or(""); if target == "now" { fold(&mut now, "now", ch, prob, mean, lo, hi); continue; } let e = byh.entry(h).or_insert_with(|| json!({"h": h, "p": {}, "plays": {}, "add": {}})); if target.starts_with("add") || target.starts_with("p_") || target == "too_soon" { e["window_start"] = json!(week); } else { e["week"] = json!(week); } fold(e, &target, ch, prob, mean, lo, hi); } now_out = now["now"].clone(); let mut v: Vec<(i64, Value)> = byh.into_iter().collect(); v.sort_by_key(|x| x.0); fc = v.into_iter().map(|x| x.1).collect(); } // Chart runs: rows whose artist field names this artist (same matching as the panel, roughly). let key = crate::model::panel::key(&name); let mut charts: Vec = Vec::new(); if key.chars().count() >= 3 { let like = format!("%{}%", name.to_uppercase()); for r in c.prepare("SELECT chart, year, week, position, artist, title FROM hitlisten_charts WHERE chart IN ('t40', 'airplay') AND upper(artist) LIKE ?1 ORDER BY year DESC, week DESC LIMIT 400")? .query_map([like], |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?, r.get::<_, i64>(2)?, r.get::<_, i64>(3)?, r.get::<_, String>(4)?, r.get::<_, String>(5)?)))? { let (chart, y, w, pos, art, title) = r?; let names: Vec = art.to_lowercase().split(&[',', '&'][..]).flat_map(|p| p.split(" feat").map(str::to_string).collect::>()) .flat_map(|p| p.split(" x ").map(crate::model::panel::key).collect::>()).collect(); if !names.iter().any(|n| *n == key) && crate::model::panel::key(&art) != key { continue; } charts.push(json!({"chart": chart, "year": y, "week": w, "position": pos, "title": title})); } } let bauer: Value = bauer_week(&c)?.remove(&key).map(|b| json!(b.into_iter().map(|(s, (n, mut songs))| { songs.sort_by(|x, y| y.1.cmp(&x.1)); (s, json!({"plays": n, "songs": songs.into_iter().take(5).map(|(t, n)| json!({"title": t, "plays": n})).collect::>()})) }).collect::>())).unwrap_or(Value::Null); ok(json!({ "id": id, "name": name, "bauer": bauer, "country": a["country"], "gender": a["gender"], "description": a["description"], "debut": a["lifespan"]["beginYear"], "type": a["type"], "image": image, "top_tracks": top, "weeks": weeks, "plays": plays, "forecasts": fc, "now": now_out, "charts": charts, })) } /// One artist's forecast under a changed chart situation. Overrides (all optional): /// entry weeks since a new chart entry (a release that charted), "none" = never /// t40 position on the latest Track Top-40 (0 = not on it) /// air position on the latest Airplay Top-20 (0 = not on it) /// h = 0..12: the add window starts h weeks after the latest week; plays are for week max(h, 1). fn whatif(st: &State, q: &HashMap) -> Result { let guard = st.models.read().unwrap(); let Some(m) = guard.as_ref() else { return Ok((503, "application/json", Arc::new(json!({"loading": true}).to_string()))) }; let Some(&a) = m.index.get(q.get("id").map(String::as_str).unwrap_or("")) else { return Ok((404, "application/json", Arc::new(json!({"error": "artist not in the model"}).to_string()))); }; let h: usize = q.get("h").and_then(|v| v.parse().ok()).unwrap_or(0).min(MAX_H); let d = &m.direct[h.max(1) - 1]; let am = &m.adds[h]; let p = &m.panel; let t0 = p.w() - 1; let chart = p.chart(a, t0); let num = |k: &str| q.get(k).filter(|v| !v.is_empty()).and_then(|v| v.parse::().ok()); let entry: Option> = q.get("entry").filter(|v| !v.is_empty()).map(|v| if v == "none" { None } else { v.parse().ok() }); let (t40, air) = (num("t40"), num("air")); // The scenario: a release in the window (default) or none. let release = q.get("release").map(|v| v != "no").unwrap_or(true); // ...and whether that release is placed on New Music Friday Denmark (default: no). let nmf = q.get("nmf").is_some_and(|v| v == "yes"); let over = move |x: &mut [f64], idx: [usize; 4]| set_chart(x, idx, entry, t40, air); let run = |overrides: bool| -> Value { let f: Option<&dyn Fn(&mut [f64], [usize; 4])> = if overrides { Some(&over) } else { None }; // A new release: the release-event model; no release: the window model (current songs only). let (add_c, add_any) = if release { m.events.predict_at(p, &m.rot, a, t0, h, crate::model::adds::Scenario::new(true, nmf).at(h), f) } else { am.predict(p, &m.rot, a, t0, crate::model::adds::Scenario::new(false, false), f) }; let mut x = vec![0.0; P]; let mut mu = [0.0; C]; for c in 0..C { features::row(p, a, c, t0, t0 + h.max(1), &mut x); if overrides { over(&mut x, CHART_IDX_CHANNEL); } mu[c] = glm::dot(&d.nb, &x).clamp(-30.0, 12.0).exp(); } let sims = 4000; let shape = 1.0 / d.alpha; let mut rng = Rng(0xa1 ^ a as u64); let mut tot = Vec::with_capacity(sims); for _ in 0..sims { let g = rng.gamma(shape) / shape; tot.push((0..C).map(|c| rng.poisson(mu[c] * g)).sum::()); } tot.sort_by(f64::total_cmp); let ch = |v: &[f64; C]| CHANNELS.iter().zip(v).map(|(c, p)| (c.to_string(), json!(p))).collect::>(); json!({"add_any": add_any, "add": ch(&add_c), "mean": mu.iter().sum::(), "lo": tot[sims / 10], "hi": tot[sims * 9 / 10], "plays": ch(&mu)}) }; let now: serde_json::Map = (0..C).filter(|&c| m.rot.on(a, c, t0)).map(|c| (CHANNELS[c].to_string(), json!(p.y(a, c, t0)))).collect(); ok(json!({ "h": h, "release": release, "nmf": nmf, "p_release": crate::model::adds::p_release(p, a, t0), "p_nmf": crate::model::adds::p_nmf(p, a, t0), "too_soon": crate::model::adds::too_soon(p, a, t0, h), "nmf_history": p.nmf_dk[a].iter().rev().take(8).map(|(d, pos)| json!({"friday": d.to_string(), "position": pos})).collect::>(), "window_start": (p.weeks[t0] + chrono::Duration::weeks(h as i64 + 1)).to_string(), "current": {"t40": chart.t40_rank, "air": chart.air_rank, "entry": if chart.weeks_since_entry == u16::MAX { Value::Null } else { json!(chart.weeks_since_entry) }, "t40_hits": chart.t40_hits, "air_hits": chart.air_hits, "in_rotation": now}, "base": run(false), "scenario": run(true), })) }