From 8f8431eed02d6fd5399239ed82ae52bd06176606 Mon Sep 17 00:00:00 2001 From: Miguel Palhas Date: Sun, 23 Aug 2026 12:25:04 +0100 Subject: [PATCH] fix(api): rescore release decks at read time GET .../releases returned the stored score column, frozen at search time. Policy tuning never reached an existing deck. Recompute from parsed/size/seeders against the current policy and re-sort by bucket then score; the stored column stays for the daemon's grab-time winner pick. Closes #114 --- crates/arr-api/src/movies.rs | 116 ++++++++++++++++++++++++++++++++++- crates/arr-api/src/series.rs | 13 +++- 2 files changed, 126 insertions(+), 3 deletions(-) diff --git a/crates/arr-api/src/movies.rs b/crates/arr-api/src/movies.rs index e117816..6ba56d0 100644 --- a/crates/arr-api/src/movies.rs +++ b/crates/arr-api/src/movies.rs @@ -1,3 +1,6 @@ +use arr_core::policy::Candidate; +use arr_core::score::score; +use arr_core::{ParsedRelease, Policy}; use axum::extract::{Path, Query, State}; use axum::http::StatusCode; use axum::response::{IntoResponse, Response}; @@ -503,12 +506,58 @@ pub async fn releases( Path(id): Path, ) -> Result>, ApiError> { load_movie(&state, id).await?; - let releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN movie_releases mr ON mr.release_id = r.id WHERE mr.movie_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id) + let mut releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN movie_releases mr ON mr.release_id = r.id WHERE mr.movie_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id) .fetch_all(pool(&state)?) .await?; + let policy = state + .database() + .ok_or(ApiError::Unavailable)? + .movie_policy(id) + .await + .map_err(|error| ApiError::Database(error.to_string()))? + .ok_or(ApiError::NotFound)? + .policy; + rescore(&mut releases, &policy)?; Ok(Json(releases)) } +/// Recompute each release's score against the current policy and re-sort +/// (`DESIGN.md` §5.5). The stored `score` column is grab-time truth for the +/// daemon's winner pick; the deck the user sees must reflect policy tuning +/// made since the release was last searched, not whatever was true then. +/// +/// Score magnitudes stay far below `f64`'s 52-bit mantissa (they are sums of +/// policy weights in the thousands), so the `i64` -> `f64` cast into the +/// column's storage type is exact. +#[allow(clippy::cast_precision_loss)] +pub(crate) fn rescore(releases: &mut [Release], policy: &Policy) -> Result<(), ApiError> { + let mut totals = Vec::with_capacity(releases.len()); + for release in releases.iter() { + let parsed: ParsedRelease = serde_json::from_value(release.parsed.clone()) + .map_err(|error| ApiError::Database(error.to_string()))?; + let seeders = u32::try_from(release.seeders.unwrap_or(0)).unwrap_or(u32::MAX); + let size = u64::try_from(release.size).unwrap_or(0); + totals.push(score(policy, Candidate::PreGrab(&parsed), size, seeders).total); + } + let mut indices: Vec = (0..releases.len()).collect(); + indices.sort_by_key(|&i| (bucket(releases[i].verdict.as_deref()), -totals[i])); + + for (release, &total) in releases.iter_mut().zip(&totals) { + release.score = Some(total as f64); + } + let sorted: Vec = indices.into_iter().map(|i| releases[i].clone()).collect(); + releases.clone_from_slice(&sorted); + Ok(()) +} + +fn bucket(verdict: Option<&str>) -> u8 { + match verdict { + Some("eligible") => 0, + Some("waived") => 1, + _ => 2, + } +} + #[utoipa::path( get, path = "/api/movies/{movie_id}/files", tag = "movies", params(("movie_id" = i64, Path, description = "Movie row id")), @@ -956,6 +1005,71 @@ mod tests { ); } + /// #114: a deck must score against the current policy, not whatever the + /// score was when the release was last searched — tuning must reach what + /// the user sees without a re-search. + #[tokio::test] + async fn the_deck_rescores_against_the_current_policy_not_the_stored_score() { + let (_dir, state, base) = application().await; + let movie = add_movie(&base, 693_134, 1).await; + let movie_id = movie["id"].as_i64().expect("id"); + let pool = state.database().expect("database").pool(); + + let name = "Dune Part Two 2024 1080p BluRay x264-GROUP"; + let parsed = arr_parse::parse(name); + let size_bytes: u64 = 20 * (1 << 30); + let seeders: u32 = 50; + let size: i64 = i64::try_from(size_bytes).expect("size fits i64"); + + let release_id = sqlx::query( + "INSERT INTO releases (indexer_id, guid, name, size, seeders, download_url, parsed, score, verdict) + VALUES (7, 'guid', ?, ?, ?, 'url', ?, -12345, 'eligible')", + ) + .bind(name) + .bind(size) + .bind(i64::from(seeders)) + .bind(serde_json::to_string(&parsed).expect("parsed json")) + .execute(pool) + .await + .expect("release") + .last_insert_rowid(); + sqlx::query("INSERT INTO movie_releases (movie_id, release_id) VALUES (?, ?)") + .bind(movie_id) + .bind(release_id) + .execute(pool) + .await + .expect("association"); + + let policy = state + .database() + .expect("database") + .movie_policy(movie_id) + .await + .expect("policy") + .expect("movie has a policy") + .policy; + let expected = arr_core::score::score( + &policy, + arr_core::policy::Candidate::PreGrab(&parsed), + size_bytes, + seeders, + ) + .total; + #[allow(clippy::cast_precision_loss)] + let expected = expected as f64; + + let releases: Vec = + reqwest::get(format!("{base}/api/movies/{movie_id}/releases")) + .await + .expect("releases") + .json() + .await + .expect("release json"); + + assert_ne!(releases[0]["score"].as_f64(), Some(-12345.0)); + assert_eq!(releases[0]["score"].as_f64(), Some(expected)); + } + #[tokio::test] async fn a_full_action_queue_returns_service_unavailable() { let (_dir, state, base) = application().await; diff --git a/crates/arr-api/src/series.rs b/crates/arr-api/src/series.rs index 0df4b79..2cad2b5 100644 --- a/crates/arr-api/src/series.rs +++ b/crates/arr-api/src/series.rs @@ -29,7 +29,7 @@ use chrono::{DateTime, NaiveDate, NaiveTime, Utc}; use serde::{Deserialize, Serialize}; use utoipa::{IntoParams, ToSchema}; -use crate::movies::{pool, Accepted, ApiError, ErrorBody, Release}; +use crate::movies::{pool, rescore, Accepted, ApiError, ErrorBody, Release}; use crate::owners::Owner; use crate::state::{AppState, EpisodeCommand}; @@ -844,9 +844,18 @@ pub async fn episode_releases( Path(id): Path, ) -> Result>, ApiError> { load_episode(&state, id).await?; - let releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN episode_releases er ON er.release_id = r.id WHERE er.episode_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id) + let mut releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN episode_releases er ON er.release_id = r.id WHERE er.episode_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id) .fetch_all(pool(&state)?) .await?; + let policy = state + .database() + .ok_or(ApiError::Unavailable)? + .episode_policy(id) + .await + .map_err(|error| ApiError::Database(error.to_string()))? + .ok_or(ApiError::EpisodeNotFound)? + .policy; + rescore(&mut releases, &policy)?; Ok(Json(releases)) }