New entries and re-entries (NY/RE) are kept; a week without exactly 20 rows is logged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
113 lines
5.5 KiB
Rust
113 lines
5.5 KiB
Rust
//! airplay: collects what Danish radio stations play, for modelling when artists get played again.
|
|
//!
|
|
//! airplay collect [--db data/airplay.db] [--days 7] [--all-bauer] [--only dr|bauer|hitlisten] [--backfill]
|
|
//! airplay stats [--db data/airplay.db]
|
|
//!
|
|
//! --backfill fetches all history at once (every DR artist page, the whole Hitlisten archive);
|
|
//! without it a run takes a bounded slice, which is what the daily timer does.
|
|
|
|
mod bauer;
|
|
mod db;
|
|
mod dr;
|
|
mod hitlisten;
|
|
mod http;
|
|
|
|
use anyhow::Result;
|
|
use chrono::Utc;
|
|
use rusqlite::params;
|
|
|
|
fn arg(args: &[String], name: &str) -> Option<String> {
|
|
args.iter().position(|a| a == name).and_then(|i| args.get(i + 1)).cloned()
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
let args: Vec<String> = std::env::args().collect();
|
|
let db_path = arg(&args, "--db").unwrap_or_else(|| "data/airplay.db".into());
|
|
if let Some(dir) = std::path::Path::new(&db_path).parent() {
|
|
std::fs::create_dir_all(dir)?;
|
|
}
|
|
let db = db::Db::open(&db_path)?;
|
|
match args.get(1).map(String::as_str) {
|
|
Some("collect") => collect(&db, &args, &db_path),
|
|
Some("stats") => stats(&db),
|
|
_ => {
|
|
eprintln!("usage: airplay collect [--db FILE] [--days 7] [--all-bauer] [--only dr|bauer|hitlisten] [--backfill]\n airplay stats [--db FILE]");
|
|
std::process::exit(2);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn collect(db: &db::Db, args: &[String], db_path: &str) -> Result<()> {
|
|
let days: i64 = arg(args, "--days").and_then(|d| d.parse().ok()).unwrap_or(7);
|
|
let only = arg(args, "--only");
|
|
let wants = |source: &str| only.as_deref().map_or(true, |o| o == source);
|
|
let backfill = args.iter().any(|a| a == "--backfill");
|
|
let http = http::Http::new(400)?;
|
|
let started = Utc::now().to_rfc3339();
|
|
db.conn.execute("INSERT INTO runs (started_at) VALUES (?1)", params![started])?;
|
|
let run = db.conn.last_insert_rowid();
|
|
let mut log: Vec<String> = Vec::new();
|
|
let mut new = 0;
|
|
let step = |name: &str, r: Result<String>, log: &mut Vec<String>| match r {
|
|
Ok(msg) => { println!("{name}: {msg}"); }
|
|
Err(e) => { eprintln!("{name}: {e}"); log.push(format!("{name}: {e}")); }
|
|
};
|
|
|
|
if wants("dr") {
|
|
let r = dr::collect_plays(db, &http, days, &mut log);
|
|
if let Ok(n) = &r { new += n; }
|
|
step("dr plays", r.map(|n| format!("{n} new")), &mut log);
|
|
let dir = std::path::Path::new(db_path).parent().unwrap_or(std::path::Path::new(".")).join("rotations");
|
|
let r = dr::collect_rotation_pdf(db, &http, &dir);
|
|
step("dr rotation list", r.map(|f| f.map(|f| format!("saved {f}")).unwrap_or_else(|| "unchanged".into())), &mut log);
|
|
let r = dr::collect_artists(db, &http, 6, if backfill { usize::MAX } else { 400 }, &mut log);
|
|
step("dr artist pages", r.map(|n| format!("{n} fetched")), &mut log);
|
|
}
|
|
if wants("bauer") {
|
|
match bauer::stations(db, &http, args.iter().any(|a| a == "--all-bauer")) {
|
|
Ok(stations) => {
|
|
for (code, name) in stations {
|
|
let r = bauer::collect(db, &http, &code, days, &mut log);
|
|
if let Ok(n) = &r { new += n; }
|
|
step(&format!("bauer {code} ({name})"), r.map(|n| format!("{n} new")), &mut log);
|
|
}
|
|
}
|
|
Err(e) => step("bauer stations", Err(e), &mut log),
|
|
}
|
|
}
|
|
if wants("hitlisten") {
|
|
let r = hitlisten::collect(db, &http, if backfill { usize::MAX } else { 60 }, &mut log);
|
|
step("hitlisten airplay chart", r.map(|n| format!("{n} weeks fetched")), &mut log);
|
|
}
|
|
db.conn.execute(
|
|
"UPDATE runs SET finished_at = ?1, new_plays = ?2, errors = ?3, log = ?4 WHERE id = ?5",
|
|
params![Utc::now().to_rfc3339(), new as i64, log.len() as i64, log.join("\n"), run],
|
|
)?;
|
|
println!("{new} new plays, {} problem(s)", log.len());
|
|
for l in log.iter().take(20) { eprintln!(" {l}"); }
|
|
Ok(())
|
|
}
|
|
|
|
fn stats(db: &db::Db) -> Result<()> {
|
|
let mut st = db.conn.prepare(
|
|
"SELECT p.station, coalesce(s.name, p.station), count(*), min(played_at), max(played_at), count(DISTINCT artist)
|
|
FROM plays p LEFT JOIN stations s ON s.code = p.station GROUP BY p.station ORDER BY count(*) DESC")?;
|
|
println!("{:<12} {:<22} {:>7} {:>8} {:<20} {}", "station", "name", "plays", "artists", "from", "to");
|
|
let rows = st.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?, r.get::<_, i64>(2)?,
|
|
r.get::<_, String>(3)?, r.get::<_, String>(4)?, r.get::<_, i64>(5)?)))?;
|
|
for r in rows {
|
|
let (code, name, n, from, to, artists) = r?;
|
|
println!("{code:<12} {name:<22} {n:>7} {artists:>8} {from:<20} {to}");
|
|
}
|
|
let weeks: i64 = db.conn.query_row("SELECT count(*) FROM dr_artist_weeks", [], |r| r.get(0))?;
|
|
let artists: i64 = db.conn.query_row("SELECT count(*) FROM dr_artists", [], |r| r.get(0))?;
|
|
let pdfs: i64 = db.conn.query_row("SELECT count(*) FROM dr_rotation_pdfs", [], |r| r.get(0))?;
|
|
println!("DR artist history: {artists} artists, {weeks} artist-week-channel rows; rotation PDFs: {pdfs}");
|
|
hitlisten::create_tables(db)?;
|
|
let (n, first, last): (i64, Option<String>, Option<String>) = db.conn.query_row(
|
|
"SELECT count(DISTINCT year * 100 + week), min(printf('%d-W%02d', year, week)), max(printf('%d-W%02d', year, week)) FROM hitlisten_airplay",
|
|
[], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)))?;
|
|
println!("Hitlisten airplay chart: {n} weeks ({} to {})", first.unwrap_or_default(), last.unwrap_or_default());
|
|
Ok(())
|
|
}
|