def get_stock_notetypes(
col: anki.collection.Collection,
) -> List[Tuple[str, Callable[[anki.collection.Collection],
anki.models.NoteType]]]:
out: List[Tuple[str, Callable[[anki.collection.Collection],
anki.models.NoteType]]] = []
# add standard
for (kind, func) in [
(StockNotetypeKind.BASIC, addBasicModel),
(StockNotetypeKind.BASIC_TYPING, addBasicTypingModel),
(StockNotetypeKind.BASIC_AND_REVERSED, addForwardReverse),
(
StockNotetypeKind.BASIC_OPTIONAL_REVERSED,
addForwardOptionalReverse,
),
(StockNotetypeKind.CLOZE, addClozeModel),
]:
m = from_json_bytes(col._backend.get_stock_notetype_legacy(kind))
out.append((m["name"], func))
# add extras from add-ons
for (name_or_func, func) in models:
if not isinstance(name_or_func, str):
name = name_or_func()
else:
name = name_or_func
out.append((name, func))
return out
def get_stock_notetypes(
col: anki.collection.Collection,
) -> list[tuple[str, Callable[[anki.collection.Collection],
anki.models.NotetypeDict]]]:
out: list[tuple[str, Callable[[anki.collection.Collection],
anki.models.NotetypeDict]]] = []
# add standard
for kind in [
StockNotetypeKind.BASIC,
StockNotetypeKind.BASIC_TYPING,
StockNotetypeKind.BASIC_AND_REVERSED,
StockNotetypeKind.BASIC_OPTIONAL_REVERSED,
StockNotetypeKind.CLOZE,
]:
note_type = from_json_bytes(
col._backend.get_stock_notetype_legacy(kind))
def instance_getter(
model: Any,
) -> Callable[[anki.collection.Collection], anki.models.NotetypeDict]:
return lambda col: model
out.append((note_type["name"], instance_getter(note_type)))
# add extras from add-ons
for (name_or_func, func) in models:
if not isinstance(name_or_func, str):
name = name_or_func()
else:
name = name_or_func
out.append((name, func))
return out
def get_stock_notetypes(
col: anki.collection.Collection,
) -> List[Tuple[str, Callable[[anki.collection.Collection], anki.models.NotetypeDict]]]:
out: List[
Tuple[str, Callable[[anki.collection.Collection], anki.models.NotetypeDict]]
] = []
# add standard
for kind in [
StockNotetypeKind.BASIC,
StockNotetypeKind.BASIC_TYPING,
StockNotetypeKind.BASIC_AND_REVERSED,
StockNotetypeKind.BASIC_OPTIONAL_REVERSED,
StockNotetypeKind.CLOZE,
]:
m = from_json_bytes(col._backend.get_stock_notetype_legacy(kind))
def instance_getter(
col: anki.collection.Collection,
) -> anki.models.NotetypeDict:
return m # pylint:disable=cell-var-from-loop
out.append((m["name"], instance_getter))
# add extras from add-ons
for (name_or_func, func) in models:
if not isinstance(name_or_func, str):
name = name_or_func()
else:
name = name_or_func
out.append((name, func))
return out
def _db_command(self, input: Dict[str, Any]) -> Any:
try:
return from_json_bytes(self._backend.db_command(to_json_bytes(input)))
except Exception as e:
err_bytes = bytes(e.args[0])
err = pb.BackendError()
err.ParseFromString(err_bytes)
raise backend_exception_to_pylib(err)
def restoreToDefault(self, conf: DeckConfig) -> None:
oldOrder = conf["new"]["order"]
new = from_json_bytes(self.col._backend.new_deck_config_legacy())
new["id"] = conf["id"]
new["name"] = conf["name"]
self.update_config(new)
# if it was previously randomized, re-sort
if not oldOrder:
self.col.sched.resortConf(new)
def new_field(self, name: str) -> FieldDict:
assert isinstance(name, str)
notetype = from_json_bytes(
self.col._backend.get_stock_notetype_legacy(
StockNotetypeKind.BASIC))
field = notetype["flds"][0]
field["name"] = name
field["ord"] = None
return field
def _db_command(self, input: dict[str, Any]) -> Any:
bytes_input = to_json_bytes(input)
try:
return from_json_bytes(self._backend.db_command(bytes_input))
except Exception as error:
err_bytes = bytes(error.args[0])
err = backend_pb2.BackendError()
err.ParseFromString(err_bytes)
raise backend_exception_to_pylib(err)
def new(self, name: str) -> NotetypeDict:
"Create a new model, and return it."
# caller should call save() after modifying
notetype = from_json_bytes(
self.col._backend.get_stock_notetype_legacy(
StockNotetypeKind.BASIC))
notetype["flds"] = []
notetype["tmpls"] = []
notetype["name"] = name
return notetype
def new_template(self, name: str) -> TemplateDict:
notetype = from_json_bytes(
self.col._backend.get_stock_notetype_legacy(
StockNotetypeKind.BASIC))
template = notetype["tmpls"][0]
template["name"] = name
template["qfmt"] = ""
template["afmt"] = ""
template["ord"] = None
return template
def new_deck_legacy(self, filtered: bool) -> DeckDict:
deck = from_json_bytes(self.col._backend.new_deck_legacy(filtered))
if deck["dyn"]:
# Filtered decks are now created via a scheduler method, but old unit
# tests still use this method. Set the default values to what the tests
# expect: one empty search term, and ordering by oldest first.
del deck["terms"][1]
deck["terms"][0][0] = ""
deck["terms"][0][2] = 0
return deck
def add_config(self,
name: str,
clone_from: Optional[DeckConfig] = None) -> DeckConfig:
if clone_from is not None:
conf = copy.deepcopy(clone_from)
conf["id"] = 0
else:
conf = from_json_bytes(self.col._backend.new_deck_config_legacy())
conf["name"] = name
self.update_config(conf)
return conf
def get(self, id: NotetypeId) -> Optional[NotetypeDict]:
"Get model with ID, or None."
# deal with various legacy input types
if id is None:
return None
elif isinstance(id, str):
id = int(id)
nt = self._get_cached(id)
if not nt:
try:
nt = from_json_bytes(self.col._backend.get_notetype_legacy(id))
self._update_cache(nt)
except NotFoundError:
return None
return nt
def get_immutable(self, key: str) -> Any:
try:
return from_json_bytes(self.col._backend.get_config_json(key))
except NotFoundError as exc:
raise KeyError from exc
def deckDueTree(self) -> List:
"List of (base name, did, rev, lrn, new, children)"
print(
"deckDueTree() is deprecated; use decks.deck_tree() for a tree without counts, or sched.deck_due_tree()"
)
return from_json_bytes(self.col._backend.deck_tree_legacy())[5]
def card_stats() -> bytes:
args = from_json_bytes(request.data)
return aqt.mw.col.card_stats_data(CardId(args["cardId"]))
def deck_configs_for_update() -> bytes:
args = from_json_bytes(request.data)
return aqt.mw.col.decks.get_deck_configs_for_update(
deck_id=args["deckId"]).SerializeToString()
def graph_data() -> bytes:
args = from_json_bytes(request.data)
return aqt.mw.col.graph_data(search=args["search"], days=args["days"])
def get_all_legacy(self) -> List[Deck]:
return list(
from_json_bytes(self.col._backend.get_all_decks_legacy()).values())
def new_deck_legacy(self, filtered: bool) -> Deck:
return from_json_bytes(self.col._backend.new_deck_legacy(filtered))
def get_legacy(self, did: DeckId) -> DeckDict | None:
try:
return from_json_bytes(self.col._backend.get_deck_legacy(did))
except NotFoundError:
return None
def get_legacy(self, did: int) -> Optional[Deck]:
try:
return from_json_bytes(self.col._backend.get_deck_legacy(did))
except NotFoundError:
return None
def change_notetype_info() -> bytes:
args = from_json_bytes(request.data)
return aqt.mw.col.models.change_notetype_info(
old_notetype_id=args["oldNotetypeId"],
new_notetype_id=args["newNotetypeId"])
def deck_configs_for_update() -> bytes:
args = from_json_bytes(request.data)
msg = aqt.mw.col.decks.get_deck_configs_for_update(deck_id=args["deckId"])
msg.have_addons = aqt.mw.addonManager.dirty
return msg.SerializeToString()
def i18n_resources() -> bytes:
args = from_json_bytes(request.data)
return aqt.mw.col.i18n_resources(modules=args["modules"])
def _add_stock_notetype(col: anki.collection.Collection,
kind: StockNotetypeKind.V) -> anki.models.NoteType:
m = from_json_bytes(col._backend.get_stock_notetype_legacy(kind))
col.models.add(m)
return m
def all_config(self) -> List[Config]:
"A list of all deck config."
return list(from_json_bytes(
self.col._backend.all_deck_config_legacy()))
def _get_stock_notetype(
col: anki.collection.Collection, kind: StockNotetypeKind.V
) -> anki.models.NotetypeDict:
return from_json_bytes(col._backend.get_stock_notetype_legacy(kind))
def get_config(self, conf_id: int) -> Optional[DeckConfig]:
try:
return from_json_bytes(
self.col._backend.get_deck_config_legacy(conf_id))
except NotFoundError:
return None
def all_config(self) -> Dict[str, Any]:
"This is a debugging aid. Prefer .get_config() when you know the key you need."
return from_json_bytes(self._backend.get_all_config())
def get_config(self, conf_id: DeckConfigId) -> DeckConfigDict | None:
try:
return from_json_bytes(
self.col._backend.get_deck_config_legacy(conf_id))
except NotFoundError:
return None
