use new API for test scheduler

Avoids duplicate work, and is a step towards allowing the next
states to be modified by third-party code.

Also:

- fixed incorrect underlined count, due to reviews being labeled as
learning cards
- fixed reviewer not refreshing when undoing a test review, by splitting
up backend queue rebuilding from frontend reviewer refresh
- moved answering into a CollectionOp

pylib/.pylintrc

@@ -7,7 +7,8 @@ ignored-classes=
   BrowserColumns,
   BrowserRow,
   FormatTimespanIn,
-  AnswerCardIn,
+  CardAnswer,
+  QueuedCards,
   UnburyDeckIn,
   BuryOrSuspendCardsIn,
   NoteIsDuplicateOrEmptyOut,

pylib/anki/_backend/genbackend.py

@@ -34,7 +34,12 @@ LABEL_REQUIRED = 2
 LABEL_REPEATED = 3
 
 # messages we don't want to unroll in codegen
-SKIP_UNROLL_INPUT = {"TranslateString", "SetPreferences", "UpdateDeckConfigs"}
+SKIP_UNROLL_INPUT = {
+    "TranslateString",
+    "SetPreferences",
+    "UpdateDeckConfigs",
+    "AnswerCard",
+}
 SKIP_UNROLL_OUTPUT = {"GetPreferences"}
 
 SKIP_DECODE = {"Graphs", "GetGraphPreferences"}

pylib/anki/cards.py

@@ -28,6 +28,7 @@ from anki.sound import AVTag
 
 # types
 CardId = NewType("CardId", int)
+BackendCard = _pb.Card
 
 
 class Card:
@@ -43,7 +44,10 @@ class Card:
     type: CardType
 
     def __init__(
-        self, col: anki.collection.Collection, id: Optional[CardId] = None
+        self,
+        col: anki.collection.Collection,
+        id: Optional[CardId] = None,
+        backend_card: Optional[BackendCard] = None,
     ) -> None:
         self.col = col.weakref()
         self.timerStarted = None
@@ -52,6 +56,8 @@ class Card:
             # existing card
             self.id = id
             self.load()
+        elif backend_card:
+            self._load_from_backend_card(backend_card)
         else:
             # new card with defaults
             self._load_from_backend_card(_pb.Card())

pylib/anki/scheduler/v3.py

@@ -11,18 +11,21 @@ as '2' internally.
 
 from __future__ import annotations
 
-from typing import Tuple, Union
+from typing import Literal, Sequence, Tuple, Union
 
 import anki._backend.backend_pb2 as _pb
-from anki.cards import Card
+from anki.cards import Card, CardId
+from anki.collection import OpChanges
 from anki.consts import *
 from anki.scheduler.base import CongratsInfo
 from anki.scheduler.legacy import SchedulerBaseWithLegacy
 from anki.types import assert_exhaustive
 from anki.utils import intTime
 
-QueuedCards = _pb.GetQueuedCardsOut.QueuedCards
+QueuedCards = _pb.QueuedCards
 SchedulingState = _pb.SchedulingState
+NextStates = _pb.NextCardStates
+CardAnswer = _pb.CardAnswer
 
 
 class Scheduler(SchedulerBaseWithLegacy):
@@ -34,16 +37,13 @@ class Scheduler(SchedulerBaseWithLegacy):
     # Fetching the next card
     ##########################################################################
 
-    def reset(self) -> None:
-        # backend automatically resets queues as operations are performed
-        pass
-
     def get_queued_cards(
         self,
         *,
         fetch_limit: int = 1,
         intraday_learning_only: bool = False,
     ) -> Union[QueuedCards, CongratsInfo]:
+        "Returns one or more card ids, or the congratulations screen info."
         info = self.col._backend.get_queued_cards(
             fetch_limit=fetch_limit, intraday_learning_only=intraday_learning_only
         )
@@ -56,6 +56,57 @@ class Scheduler(SchedulerBaseWithLegacy):
             assert_exhaustive(kind)
             assert False
 
+    def next_states(self, card_id: CardId) -> NextStates:
+        "New states corresponding to each answer button press."
+        return self.col._backend.get_next_card_states(card_id)
+
+    def describe_next_states(self, next_states: NextStates) -> Sequence[str]:
+        "Labels for each of the answer buttons."
+        return self.col._backend.describe_next_states(next_states)
+
+    # Answering a card
+    ##########################################################################
+
+    def build_answer(
+        self, *, card: Card, states: NextStates, rating: CardAnswer.Rating.V
+    ) -> CardAnswer:
+        "Build input for answer_card()."
+        if rating == CardAnswer.AGAIN:
+            new_state = states.again
+        elif rating == CardAnswer.HARD:
+            new_state = states.hard
+        elif rating == CardAnswer.GOOD:
+            new_state = states.good
+        elif rating == CardAnswer.EASY:
+            new_state = states.easy
+        else:
+            assert False, "invalid rating"
+
+        return CardAnswer(
+            card_id=card.id,
+            current_state=states.current,
+            new_state=new_state,
+            rating=rating,
+            answered_at_millis=intTime(1000),
+            milliseconds_taken=card.timeTaken(),
+        )
+
+    def answer_card(self, input: CardAnswer) -> OpChanges:
+        "Update card to provided state, and remove it from queue."
+        self.reps += 1
+        return self.col._backend.answer_card(input=input)
+
+    def state_is_leech(self, new_state: SchedulingState) -> bool:
+        "True if new state marks the card as a leech."
+        return self.col._backend.state_is_leech(new_state)
+
+    # Fetching the next card (legacy API)
+    ##########################################################################
+
+    def reset(self) -> None:
+        # backend automatically resets queues as operations are performed
+        pass
+
     def getCard(self) -> Optional[Card]:
         """Fetch the next card from the queue. None if finished."""
         response = self.get_queued_cards()
@@ -94,53 +145,46 @@ class Scheduler(SchedulerBaseWithLegacy):
     def reviewCount(self) -> int:
         return self.counts()[2]
 
-    # Answering a card
+    def countIdx(self, card: Card) -> int:
+        if card.queue in (QUEUE_TYPE_DAY_LEARN_RELEARN, QUEUE_TYPE_PREVIEW):
+            return QUEUE_TYPE_LRN
+        return card.queue
+
+    def answerButtons(self, card: Card) -> int:
+        return 4
+
+    def nextIvlStr(self, card: Card, ease: int, short: bool = False) -> str:
+        "Return the next interval for CARD as a string."
+        states = self.col._backend.get_next_card_states(card.id)
+        return self.col._backend.describe_next_states(states)[ease - 1]
+
+    # Answering a card (legacy API)
     ##########################################################################
 
-    def answerCard(self, card: Card, ease: int) -> None:
+    def answerCard(self, card: Card, ease: Literal[1, 2, 3, 4]) -> OpChanges:
-        assert 1 <= ease <= 4
-        assert 0 <= card.queue <= 4
-
-        self._answerCard(card, ease)
-
-        self.reps += 1
-
-    def _answerCard(self, card: Card, ease: int) -> _pb.SchedulingState:
-        states = self.col._backend.get_next_card_states(card.id)
         if ease == BUTTON_ONE:
-            new_state = states.again
+            rating = CardAnswer.AGAIN
-            rating = _pb.AnswerCardIn.AGAIN
         elif ease == BUTTON_TWO:
-            new_state = states.hard
+            rating = CardAnswer.HARD
-            rating = _pb.AnswerCardIn.HARD
         elif ease == BUTTON_THREE:
-            new_state = states.good
+            rating = CardAnswer.GOOD
-            rating = _pb.AnswerCardIn.GOOD
         elif ease == BUTTON_FOUR:
-            new_state = states.easy
+            rating = CardAnswer.EASY
-            rating = _pb.AnswerCardIn.EASY
         else:
             assert False, "invalid ease"
 
-        self.col._backend.answer_card(
+        changes = self.answer_card(
-            card_id=card.id,
+            self.build_answer(
-            current_state=states.current,
+                card=card, states=self.next_states(card_id=card.id), rating=rating
-            new_state=new_state,
+            )
-            rating=rating,
-            answered_at_millis=intTime(1000),
-            milliseconds_taken=card.timeTaken(),
         )
 
-        # fixme: tests assume card will be mutated, so we need to reload it
+        # tests assume card will be mutated, so we need to reload it
         card.load()
 
-        return new_state
+        return changes
 
-    def state_is_leech(self, new_state: SchedulingState) -> bool:
+    # Next times (legacy API)
-        "True if new state marks the card as a leech."
-        return self.col._backend.state_is_leech(new_state)
-
-    # Next times
     ##########################################################################
     # fixme: move these into tests_schedv2 in the future
 
@@ -195,19 +239,3 @@ class Scheduler(SchedulerBaseWithLegacy):
             assert False, "invalid ease"
 
         return self._interval_for_state(new_state)
-
-    # Review-related UI helpers
-    ##########################################################################
-
-    def countIdx(self, card: Card) -> int:
-        if card.queue in (QUEUE_TYPE_DAY_LEARN_RELEARN, QUEUE_TYPE_PREVIEW):
-            return QUEUE_TYPE_LRN
-        return card.queue
-
-    def answerButtons(self, card: Card) -> int:
-        return 4
-
-    def nextIvlStr(self, card: Card, ease: int, short: bool = False) -> str:
-        "Return the next interval for CARD as a string."
-        states = self.col._backend.get_next_card_states(card.id)
-        return self.col._backend.describe_next_states(states)[ease - 1]

qt/.pylintrc

@@ -12,6 +12,8 @@ ignored-classes=
   Config,
   OpChanges,
   UnburyDeckIn,
+  CardAnswer,
+  QueuedCards,
 
 [REPORTS]
 output-format=colorized

qt/aqt/deckbrowser.py

@@ -81,7 +81,7 @@ class DeckBrowser:
     def op_executed(
         self, changes: OpChanges, handler: Optional[object], focused: bool
     ) -> bool:
-        if changes.study_queues and handler is not self:
+        if changes.reviewer and handler is not self:
             self._refresh_needed = True
 
         if focused:

qt/aqt/operations/scheduling.py

@@ -9,6 +9,7 @@ import aqt
 from anki.cards import CardId
 from anki.collection import (
     CARD_TYPE_NEW,
+    Collection,
     Config,
     OpChanges,
     OpChangesWithCount,
@@ -17,6 +18,8 @@ from anki.collection import (
 from anki.decks import DeckId
 from anki.notes import NoteId
 from anki.scheduler import FilteredDeckForUpdate, UnburyDeck
+from anki.scheduler.v3 import CardAnswer
+from anki.scheduler.v3 import Scheduler as V3Scheduler
 from aqt.operations import CollectionOp
 from aqt.qt import *
 from aqt.utils import disable_help_button, getText, tooltip, tr
@@ -207,3 +210,15 @@ def unbury_deck(
     return CollectionOp(
         parent, lambda col: col.sched.unbury_deck(deck_id=deck_id, mode=mode)
     )
+
+
+def answer_card(
+    *,
+    parent: QWidget,
+    answer: CardAnswer,
+) -> CollectionOp[OpChanges]:
+    def answer_v3(col: Collection) -> OpChanges:
+        assert isinstance(col.sched, V3Scheduler)
+        return col.sched.answer_card(answer)
+
+    return CollectionOp(parent, answer_v3)

qt/aqt/overview.py

@@ -73,7 +73,7 @@ class Overview:
     def op_executed(
         self, changes: OpChanges, handler: Optional[object], focused: bool
     ) -> bool:
-        if changes.study_queues:
+        if changes.reviewer:
             self._refresh_needed = True
 
         if focused:

qt/aqt/reviewer.py

@@ -8,20 +8,25 @@ import html
 import json
 import re
 import unicodedata as ucd
+from dataclasses import dataclass
 from enum import Enum, auto
-from typing import Any, Callable, List, Match, Optional, Sequence, Tuple, Union
+from typing import Any, Callable, List, Match, Optional, Sequence, Tuple, Union, cast
 
 from PyQt5.QtCore import Qt
 
 from anki import hooks
 from anki.cards import Card, CardId
 from anki.collection import Config, OpChanges, OpChangesWithCount
+from anki.scheduler import CongratsInfo
+from anki.scheduler.v3 import CardAnswer, NextStates, QueuedCards
+from anki.scheduler.v3 import Scheduler as V3Scheduler
 from anki.tags import MARKED_TAG
 from anki.utils import stripHTML
 from aqt import AnkiQt, gui_hooks
 from aqt.operations.card import set_card_flag
 from aqt.operations.note import remove_notes
 from aqt.operations.scheduling import (
+    answer_card,
     bury_cards,
     bury_notes,
     set_due_date_dialog,
@@ -58,9 +63,55 @@ def replay_audio(card: Card, question_side: bool) -> None:
         av_player.play_tags(tags)
 
 
-class Reviewer:
+@dataclass
-    "Manage reviews.  Maintains a separate state."
+class V3CardInfo:
+    """2021 test scheduler info.
 
+    next_states is copied from the top card on initialization, and can be
+    mutated to alter the default scheduling.
+    """
+
+    queued_cards: QueuedCards
+    next_states: NextStates
+
+    @staticmethod
+    def from_queue(queued_cards: QueuedCards) -> V3CardInfo:
+        return V3CardInfo(
+            queued_cards=queued_cards, next_states=queued_cards.cards[0].next_states
+        )
+
+    def top_card(self) -> QueuedCards.QueuedCard:
+        return self.queued_cards.cards[0]
+
+    def counts(self) -> Tuple[int, List[int]]:
+        "Returns (idx, counts)."
+        counts = [
+            self.queued_cards.new_count,
+            self.queued_cards.learning_count,
+            self.queued_cards.review_count,
+        ]
+        card = self.top_card()
+        if card.queue == QueuedCards.NEW:
+            idx = 0
+        elif card.queue == QueuedCards.LEARNING:
+            idx = 1
+        else:
+            idx = 2
+        return idx, counts
+
+    @staticmethod
+    def rating_from_ease(ease: int) -> CardAnswer.Rating.V:
+        if ease == 1:
+            return CardAnswer.AGAIN
+        elif ease == 2:
+            return CardAnswer.HARD
+        elif ease == 3:
+            return CardAnswer.GOOD
+        else:
+            return CardAnswer.EASY
+
+
+class Reviewer:
     def __init__(self, mw: AnkiQt) -> None:
         self.mw = mw
         self.web = mw.web
@@ -72,6 +123,7 @@ class Reviewer:
         self.typeCorrect: str = None  # web init happens before this is set
         self.state: Optional[str] = None
         self._refresh_needed: Optional[RefreshNeeded] = None
+        self._v3: Optional[V3CardInfo] = None
         self.bottom = BottomBar(mw, mw.bottomWeb)
         hooks.card_did_leech.append(self.onLeech)
 
@@ -83,6 +135,7 @@ class Reviewer:
         self._refresh_needed = RefreshNeeded.QUEUES
         self.refresh_if_needed()
 
+    # this is only used by add-ons
     def lastCard(self) -> Optional[Card]:
         if self._answeredIds:
             if not self.card or self._answeredIds[-1] != self.card.id:
@@ -112,7 +165,7 @@ class Reviewer:
         self, changes: OpChanges, handler: Optional[object], focused: bool
     ) -> bool:
         if handler is not self:
-            if changes.study_queues:
+            if changes.reviewer:
                 self._refresh_needed = RefreshNeeded.QUEUES
             elif changes.editor:
                 self._refresh_needed = RefreshNeeded.NOTE_TEXT
@@ -133,22 +186,32 @@ class Reviewer:
     ##########################################################################
 
     def nextCard(self) -> None:
-        elapsed = self.mw.col.timeboxReached()
+        if self.check_timebox():
-        if elapsed:
+            return
-            assert not isinstance(elapsed, bool)
+
-            part1 = tr.studying_card_studied_in(count=elapsed[1])
+        self.card = None
-            mins = int(round(elapsed[0] / 60))
+        self._v3 = None
-            part2 = tr.studying_minute(count=mins)
+
-            fin = tr.studying_finish()
+        if self.mw.col.sched.version < 3:
-            diag = askUserDialog(f"{part1} {part2}", [tr.studying_continue(), fin])
+            self._get_next_v1_v2_card()
-            diag.setIcon(QMessageBox.Information)
+        else:
-            if diag.run() == fin:
+            self._get_next_v3_card()
-                return self.mw.moveToState("deckBrowser")
+
-            self.mw.col.startTimebox()
+        if not self.card:
+            self.mw.moveToState("overview")
+            return
+
+        if self._reps is None or self._reps % 100 == 0:
+            # we recycle the webview periodically so webkit can free memory
+            self._initWeb()
+
+        self._showQuestion()
+
+    def _get_next_v1_v2_card(self) -> None:
         if self.cardQueue:
             # undone/edited cards to show
-            c = self.cardQueue.pop()
+            card = self.cardQueue.pop()
-            c.startTimer()
+            card.startTimer()
             self.hadCardQueue = True
         else:
             if self.hadCardQueue:
@@ -156,15 +219,17 @@ class Reviewer:
                 # need to reset
                 self.mw.col.reset()
                 self.hadCardQueue = False
-            c = self.mw.col.sched.getCard()
+            card = self.mw.col.sched.getCard()
-        self.card = c
+        self.card = card
-        if not c:
+
-            self.mw.moveToState("overview")
+    def _get_next_v3_card(self) -> None:
+        assert isinstance(self.mw.col.sched, V3Scheduler)
+        output = self.mw.col.sched.get_queued_cards()
+        if isinstance(output, CongratsInfo):
             return
-        if self._reps is None or self._reps % 100 == 0:
+        self._v3 = V3CardInfo.from_queue(output)
-            # we recycle the webview periodically so webkit can free memory
+        self.card = Card(self.mw.col, backend_card=self._v3.top_card().card)
-            self._initWeb()
+        self.card.startTimer()
-        self._showQuestion()
 
     # Audio
     ##########################################################################
@@ -313,7 +378,20 @@ class Reviewer:
         )
         if not proceed:
             return
+
+        if v3 := self._v3:
+            assert isinstance(self.mw.col.sched, V3Scheduler)
+            answer = self.mw.col.sched.build_answer(
+                card=self.card, states=v3.next_states, rating=v3.rating_from_ease(ease)
+            )
+            answer_card(parent=self.mw, answer=answer).success(
+                lambda _: self._after_answering(ease)
+            ).run_in_background(initiator=self)
+        else:
             self.mw.col.sched.answerCard(self.card, ease)
+            self._after_answering(ease)
+
+    def _after_answering(self, ease: int) -> None:
         gui_hooks.reviewer_did_answer_card(self, self.card, ease)
         self._answeredIds.append(self.card.id)
         self.mw.autosave()
@@ -648,18 +726,27 @@ time = %(time)d;
     def _remaining(self) -> str:
         if not self.mw.col.conf["dueCounts"]:
             return ""
+
+        counts: List[Union[int, str]]
+        if v3 := self._v3:
+            idx, counts_ = v3.counts()
+            counts = cast(List[Union[int, str]], counts_)
+        else:
+            # v1/v2 scheduler
             if self.hadCardQueue:
                 # if it's come from the undo queue, don't count it separately
-            counts: List[Union[int, str]] = list(self.mw.col.sched.counts())
+                counts = list(self.mw.col.sched.counts())
             else:
                 counts = list(self.mw.col.sched.counts(self.card))
             idx = self.mw.col.sched.countIdx(self.card)
+
         counts[idx] = f"<u>{counts[idx]}</u>"
-        space = " + "
+
-        ctxt = f"<span class=new-count>{counts[0]}</span>"
+        return f"""
-        ctxt += f"{space}<span class=learn-count>{counts[1]}</span>"
+<span class=new-count>{counts[0]}</span> +
-        ctxt += f"{space}<span class=review-count>{counts[2]}</span>"
+<span class=learn-count>{counts[1]}</span> +
-        return ctxt
+<span class=review-count>{counts[2]}</span>
+"""
 
     def _defaultEase(self) -> int:
         if self.mw.col.sched.answerButtons(self.card) == 4:
@@ -695,12 +782,18 @@ time = %(time)d;
     def _answerButtons(self) -> str:
         default = self._defaultEase()
 
+        if v3 := self._v3:
+            assert isinstance(self.mw.col.sched, V3Scheduler)
+            labels = self.mw.col.sched.describe_next_states(v3.next_states)
+        else:
+            labels = None
+
         def but(i: int, label: str) -> str:
             if i == default:
                 extra = """id="defease" class="focus" """
             else:
                 extra = ""
-            due = self._buttonTime(i)
+            due = self._buttonTime(i, v3_labels=labels)
             return """
 <td align=center>%s<button %s title="%s" data-ease="%s" onclick='pycmd("ease%d");'>\
 %s</button></td>""" % (
@@ -718,9 +811,12 @@ time = %(time)d;
         buf += "</tr></table>"
         return buf
 
-    def _buttonTime(self, i: int) -> str:
+    def _buttonTime(self, i: int, v3_labels: Optional[Sequence[str]] = None) -> str:
         if not self.mw.col.conf["estTimes"]:
             return "<div class=spacer></div>"
+        if v3_labels:
+            txt = v3_labels[i - 1]
+        else:
             txt = self.mw.col.sched.nextIvlStr(self.card, i, True) or "&nbsp;"
         return f"<span class=nobold>{txt}</span><br>"
 
@@ -734,6 +830,26 @@ time = %(time)d;
             s += f" {tr.studying_it_has_been_suspended()}"
         tooltip(s)
 
+    # Timebox
+    ##########################################################################
+
+    def check_timebox(self) -> bool:
+        "True if answering should be aborted."
+        elapsed = self.mw.col.timeboxReached()
+        if elapsed:
+            assert not isinstance(elapsed, bool)
+            part1 = tr.studying_card_studied_in(count=elapsed[1])
+            mins = int(round(elapsed[0] / 60))
+            part2 = tr.studying_minute(count=mins)
+            fin = tr.studying_finish()
+            diag = askUserDialog(f"{part1} {part2}", [tr.studying_continue(), fin])
+            diag.setIcon(QMessageBox.Information)
+            if diag.run() == fin:
+                self.mw.moveToState("deckBrowser")
+                return True
+            self.mw.col.startTimebox()
+        return False
+
     # Context menu
     ##########################################################################
 

rslib/backend.proto

@@ -130,7 +130,7 @@ service SchedulingService {
   rpc GetNextCardStates(CardId) returns (NextCardStates);
   rpc DescribeNextStates(NextCardStates) returns (StringList);
   rpc StateIsLeech(SchedulingState) returns (Bool);
-  rpc AnswerCard(AnswerCardIn) returns (OpChanges);
+  rpc AnswerCard(CardAnswer) returns (OpChanges);
   rpc UpgradeScheduler(Empty) returns (Empty);
   rpc GetQueuedCards(GetQueuedCardsIn) returns (GetQueuedCardsOut);
 }
@@ -1489,7 +1489,7 @@ message NextCardStates {
   SchedulingState easy = 5;
 }
 
-message AnswerCardIn {
+message CardAnswer {
   enum Rating {
     AGAIN = 0;
     HARD = 1;
@@ -1510,26 +1510,25 @@ message GetQueuedCardsIn {
   bool intraday_learning_only = 2;
 }
 
-message GetQueuedCardsOut {
+message QueuedCards {
   enum Queue {
-    New = 0;
+    NEW = 0;
-    Learning = 1;
+    LEARNING = 1;
-    Review = 2;
+    REVIEW = 2;
   }
-
   message QueuedCard {
     Card card = 1;
     Queue queue = 2;
     NextCardStates next_states = 3;
   }
 
-  message QueuedCards {
   repeated QueuedCard cards = 1;
   uint32 new_count = 2;
   uint32 learning_count = 3;
   uint32 review_count = 4;
 }
 
+message GetQueuedCardsOut {
   oneof value {
     QueuedCards queued_cards = 1;
     CongratsInfoOut congrats_info = 2;
@@ -1548,7 +1547,7 @@ message OpChanges {
   bool browser_table = 7;
   bool browser_sidebar = 8;
   bool editor = 9;
-  bool study_queues = 10;
+  bool reviewer = 10;
 }
 
 message UndoStatus {

rslib/src/backend/ops.rs

@@ -21,7 +21,7 @@ impl From<OpChanges> for pb::OpChanges {
             browser_table: c.requires_browser_table_redraw(),
             browser_sidebar: c.requires_browser_sidebar_redraw(),
             editor: c.requires_editor_redraw(),
-            study_queues: c.requires_study_queue_rebuild(),
+            reviewer: c.requires_reviewer_redraw(),
         }
     }
 }

rslib/src/backend/scheduler/answering.rs

@@ -10,8 +10,8 @@ use crate::{
     },
 };
 
-impl From<pb::AnswerCardIn> for CardAnswer {
+impl From<pb::CardAnswer> for CardAnswer {
-    fn from(answer: pb::AnswerCardIn) -> Self {
+    fn from(answer: pb::CardAnswer) -> Self {
         CardAnswer {
             card_id: CardId(answer.card_id),
             rating: answer.rating().into(),
@@ -23,28 +23,34 @@ impl From<pb::AnswerCardIn> for CardAnswer {
     }
 }
 
-impl From<pb::answer_card_in::Rating> for Rating {
+impl From<pb::card_answer::Rating> for Rating {
-    fn from(rating: pb::answer_card_in::Rating) -> Self {
+    fn from(rating: pb::card_answer::Rating) -> Self {
         match rating {
-            pb::answer_card_in::Rating::Again => Rating::Again,
+            pb::card_answer::Rating::Again => Rating::Again,
-            pb::answer_card_in::Rating::Hard => Rating::Hard,
+            pb::card_answer::Rating::Hard => Rating::Hard,
-            pb::answer_card_in::Rating::Good => Rating::Good,
+            pb::card_answer::Rating::Good => Rating::Good,
-            pb::answer_card_in::Rating::Easy => Rating::Easy,
+            pb::card_answer::Rating::Easy => Rating::Easy,
         }
     }
 }
 
-impl From<QueuedCard> for pb::get_queued_cards_out::QueuedCard {
+impl From<QueuedCard> for pb::queued_cards::QueuedCard {
     fn from(queued_card: QueuedCard) -> Self {
         Self {
             card: Some(queued_card.card.into()),
             next_states: Some(queued_card.next_states.into()),
-            queue: queued_card.kind as i32,
+            queue: match queued_card.kind {
+                crate::scheduler::queue::QueueEntryKind::New => pb::queued_cards::Queue::New,
+                crate::scheduler::queue::QueueEntryKind::Review => pb::queued_cards::Queue::Review,
+                crate::scheduler::queue::QueueEntryKind::Learning => {
+                    pb::queued_cards::Queue::Learning
+                }
+            } as i32,
         }
     }
 }
 
-impl From<QueuedCards> for pb::get_queued_cards_out::QueuedCards {
+impl From<QueuedCards> for pb::QueuedCards {
     fn from(queued_cards: QueuedCards) -> Self {
         Self {
             cards: queued_cards.cards.into_iter().map(Into::into).collect(),

rslib/src/backend/scheduler/mod.rs

@@ -166,7 +166,7 @@ impl SchedulingService for Backend {
         Ok(state.leeched().into())
     }
 
-    fn answer_card(&self, input: pb::AnswerCardIn) -> Result<pb::OpChanges> {
+    fn answer_card(&self, input: pb::CardAnswer) -> Result<pb::OpChanges> {
         self.with_col(|col| col.answer_card(&input.into()))
             .map(Into::into)
     }

rslib/src/ops.rs

@@ -150,7 +150,19 @@ impl OpChanges {
         c.note || c.notetype
     }
 
-    pub fn requires_study_queue_rebuild(&self) -> bool {
+    pub fn requires_reviewer_redraw(&self) -> bool {
+        let c = &self.changes;
+        c.card
+            || (c.deck && self.op != Op::ExpandCollapse)
+            || (c.config && matches!(self.op, Op::SetCurrentDeck))
+            || c.deck_config
+            || c.note
+            || c.notetype
+    }
+
+    /// Internal; allows us to avoid rebuilding queues after AnswerCard,
+    /// and a few other ops as an optimization.
+    pub(crate) fn requires_study_queue_rebuild(&self) -> bool {
         let c = &self.changes;
         if self.op == Op::AnswerCard {
             return false;

rslib/src/scheduler/queue/entry.rs

@@ -39,8 +39,8 @@ impl QueueEntry {
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub(crate) enum QueueEntryKind {
     New,
-    Review,
     Learning,
+    Review,
 }
 
 impl From<&Card> for QueueEntry {