yolo/arr
3
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases Wiki Activity

fix(api): rescore release decks at read time

Browse Source 
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
This commit is contained in:
Miguel Palhas
2026-08-23 12:25:04 +01:00
parent a5b3680746
commit 8f8431eed0
2 changed files with 126 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/arr-api/src/movies.rs
+115 -1
View File
@@ -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<i64>,
) -> Result<Json<Vec<Release>>, 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<usize> = (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<Release> = 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<serde_json::Value> =
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;
crates/arr-api/src/series.rs
+11 -2
View File
@@ -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<i64>,
) -> Result<Json<Vec<Release>>, 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))
}