GitHub/Anki
1
0
Fork 0
mirror of https://github.com/ankitects/anki.git synced 2025-09-22 16:02:23 -04:00
Code Issues Projects Releases Packages 1 Wiki Activity Actions

Simplify update_memory_state

Browse source
This commit is contained in:
Daniel Pechersky 2025-09-14 11:33:59 +07:00
parent 4506ad0c97
commit e5b7ed6cad
1 changed files with 85 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

167
rslib/src/scheduler/fsrs/memory_state.rs
View file

@ -80,11 +80,7 @@ impl Collection {
SearchBuilder::all([search.into(), SearchNode::State(StateKind::New).negated()]); SearchBuilder::all([search.into(), SearchNode::State(StateKind::New).negated()]);
let revlog = self.revlog_for_srs(search)?; let revlog = self.revlog_for_srs(search)?;
let reschedule = req.as_ref().map(|e| e.reschedule).unwrap_or_default(); let reschedule = req.as_ref().map(|e| e.reschedule).unwrap_or_default();
let last_revlog_info = if reschedule { let last_revlog_info = reschedule.then(|| get_last_revlog_info(&revlog));
Some(get_last_revlog_info(&revlog))
} else {
None
};
let mut rescheduler = self let mut rescheduler = self
.get_config_bool(BoolKey::LoadBalancerEnabled) .get_config_bool(BoolKey::LoadBalancerEnabled)
.then(|| Rescheduler::new(self)) .then(|| Rescheduler::new(self))
@ -101,12 +97,26 @@ impl Collection {
)?; )?;
let mut progress = self.new_progress_handler::<ComputeMemoryProgress>(); let mut progress = self.new_progress_handler::<ComputeMemoryProgress>();
progress.update(false, |s| s.total_cards = items.len() as u32)?; progress.update(false, |s| s.total_cards = items.len() as u32)?;
let Some(req) = &req else {
// clear FSRS data if FSRS is disabled
for (idx, (card_id, _)) in items.into_iter().enumerate() {
progress.update(true, |state| state.current_cards = idx as u32 + 1)?;
let mut card = self.storage.get_card(card_id)?.or_not_found(card_id)?;
let original = card.clone();
card.clear_fsrs_data();
self.update_card_inner(&mut card, original, usn)?;
}
return Ok(());
};
let preset_desired_retention = req.preset_desired_retention;
for (idx, (card_id, item)) in items.into_iter().enumerate() { for (idx, (card_id, item)) in items.into_iter().enumerate() {
progress.update(true, |state| state.current_cards = idx as u32 + 1)?; progress.update(true, |state| state.current_cards = idx as u32 + 1)?;
let mut card = self.storage.get_card(card_id)?.or_not_found(card_id)?; let mut card = self.storage.get_card(card_id)?.or_not_found(card_id)?;
let original = card.clone(); let original = card.clone();
if let Some(req) = &req {
let preset_desired_retention = req.preset_desired_retention; 'update_card: {
// Store decay and desired retention in the card so that add-ons, card info, // Store decay and desired retention in the card so that add-ons, card info,
// stats and browser search/sorts don't need to access the deck config. // stats and browser search/sorts don't need to access the deck config.
// Unlike memory states, scheduler doesn't use decay and dr stored in the card. // Unlike memory states, scheduler doesn't use decay and dr stored in the card.
@ -117,85 +127,78 @@ impl Collection {
.unwrap_or(&preset_desired_retention); .unwrap_or(&preset_desired_retention);
card.desired_retention = Some(desired_retention); card.desired_retention = Some(desired_retention);
card.decay = decay; card.decay = decay;
if let Some(item) = item { let Some(item) = item else {
card.set_memory_state(&fsrs, Some(item), historical_retention.unwrap())?;
// if rescheduling
if let Some(reviews) = &last_revlog_info {
// and we have a last review time for the card
if let Some(last_info) = reviews.get(&card.id) {
if let Some(last_review) = &last_info.last_reviewed_at {
let days_elapsed =
timing.next_day_at.elapsed_days_since(*last_review) as i32;
// and the card's not new
if let Some(state) = &card.memory_state {
// or in (re)learning
if card.ctype == CardType::Review {
let deck = self
.get_deck(card.original_or_current_deck_id())?
.or_not_found(card.original_or_current_deck_id())?;
let deckconfig_id = deck.config_id().unwrap();
// reschedule it
let original_interval = card.interval;
let interval = fsrs.next_interval(
Some(state.stability),
desired_retention,
0,
);
card.interval = rescheduler
.as_mut()
.and_then(|r| {
r.find_interval(
interval,
1,
req.max_interval,
days_elapsed as u32,
deckconfig_id,
get_fuzz_seed(&card, true),
)
})
.unwrap_or_else(|| {
with_review_fuzz(
card.get_fuzz_factor(true),
interval,
1,
req.max_interval,
)
});
let due = if card.original_due != 0 {
&mut card.original_due
} else {
&mut card.due
};
let new_due = (timing.days_elapsed as i32)
- days_elapsed
+ card.interval as i32;
if let Some(rescheduler) = &mut rescheduler {
rescheduler.update_due_cnt_per_day(
*due,
new_due,
deckconfig_id,
);
}
*due = new_due;
// Add a rescheduled revlog entry
self.log_rescheduled_review(
&card,
original_interval,
usn,
)?;
}
}
}
}
}
} else {
// clear memory states if item is None // clear memory states if item is None
card.memory_state = None; card.memory_state = None;
break 'update_card;
};
card.set_memory_state(&fsrs, Some(item), historical_retention.unwrap())?;
// if rescheduling
let Some(reviews) = &last_revlog_info else {
break 'update_card;
};
// and we have a last review time for the card
let Some(last_info) = reviews.get(&card.id) else {
break 'update_card;
};
let Some(last_review) = &last_info.last_reviewed_at else {
break 'update_card;
};
// and the card's not new
let Some(state) = &card.memory_state else {
break 'update_card;
};
// or in (re)learning
if card.ctype != CardType::Review {
break 'update_card;
};
let deck = self
.get_deck(card.original_or_current_deck_id())?
.or_not_found(card.original_or_current_deck_id())?;
let deckconfig_id = deck.config_id().unwrap();
// reschedule it
let days_elapsed = timing.next_day_at.elapsed_days_since(*last_review) as i32;
let original_interval = card.interval;
let interval = fsrs.next_interval(Some(state.stability), desired_retention, 0);
card.interval = rescheduler
.as_mut()
.and_then(|r| {
r.find_interval(
interval,
1,
req.max_interval,
days_elapsed as u32,
deckconfig_id,
get_fuzz_seed(&card, true),
)
})
.unwrap_or_else(|| {
with_review_fuzz(
card.get_fuzz_factor(true),
interval,
1,
req.max_interval,
)
});
let due = if card.original_due != 0 {
&mut card.original_due
} else {
&mut card.due
};
let new_due =
(timing.days_elapsed as i32) - days_elapsed + card.interval as i32;
if let Some(rescheduler) = &mut rescheduler {
rescheduler.update_due_cnt_per_day(*due, new_due, deckconfig_id);
} }
} else { *due = new_due;
// clear FSRS data if FSRS is disabled // Add a rescheduled revlog entry
card.clear_fsrs_data(); self.log_rescheduled_review(&card, original_interval, usn)?;
} }
self.update_card_inner(&mut card, original, usn)?; self.update_card_inner(&mut card, original, usn)?;
} }
} }