mirror of
https://github.com/ankitects/anki.git
synced 2025-09-19 06:22:22 -04:00
741 lines
24 KiB
Python
741 lines
24 KiB
Python
# Copyright: Ankitects Pty Ltd and contributors
|
|
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
# pylint: skip-file
|
|
|
|
"""
|
|
Python bindings for Anki's Rust libraries.
|
|
|
|
Please do not access methods on the backend directly - they may be changed
|
|
or removed at any time. Instead, please use the methods on the collection
|
|
instead. Eg, don't use col.backend.all_deck_config(), instead use
|
|
col.decks.all_config()
|
|
"""
|
|
|
|
import enum
|
|
import json
|
|
import os
|
|
from dataclasses import dataclass
|
|
from typing import Any, Dict, List, Optional, Sequence, Union
|
|
|
|
import ankirspy # pytype: disable=import-error
|
|
|
|
import anki.backend_pb2 as pb
|
|
import anki.buildinfo
|
|
from anki import hooks
|
|
from anki.dbproxy import Row as DBRow
|
|
from anki.dbproxy import ValueForDB
|
|
from anki.fluent_pb2 import FluentString as TR
|
|
from anki.types import assert_impossible_literal
|
|
|
|
assert ankirspy.buildhash() == anki.buildinfo.buildhash
|
|
|
|
SchedTimingToday = pb.SchedTimingTodayOut
|
|
BuiltinSortKind = pb.BuiltinSearchOrder.BuiltinSortKind
|
|
BackendCard = pb.Card
|
|
BackendNote = pb.Note
|
|
TagUsnTuple = pb.TagUsnTuple
|
|
NoteType = pb.NoteType
|
|
DeckTreeNode = pb.DeckTreeNode
|
|
StockNoteType = pb.StockNoteType
|
|
|
|
try:
|
|
import orjson
|
|
|
|
to_json_bytes = orjson.dumps
|
|
from_json_bytes = orjson.loads
|
|
except:
|
|
# add compat layer for 32 bit builds that can't use orjson
|
|
to_json_bytes = lambda obj: json.dumps(obj).encode("utf8") # type: ignore
|
|
from_json_bytes = json.loads
|
|
|
|
|
|
class Interrupted(Exception):
|
|
pass
|
|
|
|
|
|
class StringError(Exception):
|
|
def __str__(self) -> str:
|
|
return self.args[0] # pylint: disable=unsubscriptable-object
|
|
|
|
|
|
NetworkErrorKind = pb.NetworkError.NetworkErrorKind
|
|
SyncErrorKind = pb.SyncError.SyncErrorKind
|
|
|
|
|
|
class NetworkError(StringError):
|
|
def kind(self) -> NetworkErrorKind:
|
|
return self.args[1]
|
|
|
|
|
|
class SyncError(StringError):
|
|
def kind(self) -> SyncErrorKind:
|
|
return self.args[1]
|
|
|
|
|
|
class IOError(StringError):
|
|
pass
|
|
|
|
|
|
class DBError(StringError):
|
|
pass
|
|
|
|
|
|
class TemplateError(StringError):
|
|
pass
|
|
|
|
|
|
class NotFoundError(Exception):
|
|
pass
|
|
|
|
|
|
class ExistsError(Exception):
|
|
pass
|
|
|
|
|
|
class DeckIsFilteredError(Exception):
|
|
pass
|
|
|
|
|
|
class InvalidInput(StringError):
|
|
pass
|
|
|
|
|
|
def proto_exception_to_native(err: pb.BackendError) -> Exception:
|
|
val = err.WhichOneof("value")
|
|
if val == "interrupted":
|
|
return Interrupted()
|
|
elif val == "network_error":
|
|
return NetworkError(err.localized, err.network_error.kind)
|
|
elif val == "sync_error":
|
|
return SyncError(err.localized, err.sync_error.kind)
|
|
elif val == "io_error":
|
|
return IOError(err.localized)
|
|
elif val == "db_error":
|
|
return DBError(err.localized)
|
|
elif val == "template_parse":
|
|
return TemplateError(err.localized)
|
|
elif val == "invalid_input":
|
|
return InvalidInput(err.localized)
|
|
elif val == "json_error":
|
|
return StringError(err.localized)
|
|
elif val == "not_found_error":
|
|
return NotFoundError()
|
|
elif val == "exists":
|
|
return ExistsError()
|
|
elif val == "deck_is_filtered":
|
|
return DeckIsFilteredError()
|
|
elif val == "proto_error":
|
|
return StringError(err.localized)
|
|
else:
|
|
print("unhandled error type:", val)
|
|
return StringError(err.localized)
|
|
|
|
|
|
MediaSyncProgress = pb.MediaSyncProgress
|
|
|
|
FormatTimeSpanContext = pb.FormatTimespanIn.Context
|
|
|
|
|
|
class ProgressKind(enum.Enum):
|
|
MediaSync = 0
|
|
MediaCheck = 1
|
|
|
|
|
|
@dataclass
|
|
class Progress:
|
|
kind: ProgressKind
|
|
val: Union[MediaSyncProgress, str]
|
|
|
|
|
|
def proto_progress_to_native(progress: pb.Progress) -> Progress:
|
|
kind = progress.WhichOneof("value")
|
|
if kind == "media_sync":
|
|
return Progress(kind=ProgressKind.MediaSync, val=progress.media_sync)
|
|
elif kind == "media_check":
|
|
return Progress(kind=ProgressKind.MediaCheck, val=progress.media_check)
|
|
else:
|
|
assert_impossible_literal(kind)
|
|
|
|
|
|
def _on_progress(progress_bytes: bytes) -> bool:
|
|
progress = pb.Progress()
|
|
progress.ParseFromString(progress_bytes)
|
|
native_progress = proto_progress_to_native(progress)
|
|
return hooks.bg_thread_progress_callback(True, native_progress)
|
|
|
|
|
|
class RustBackend:
|
|
def __init__(
|
|
self,
|
|
ftl_folder: Optional[str] = None,
|
|
langs: Optional[List[str]] = None,
|
|
server: bool = False,
|
|
) -> None:
|
|
# pick up global defaults if not provided
|
|
if ftl_folder is None:
|
|
ftl_folder = os.path.join(anki.lang.locale_folder, "fluent")
|
|
if langs is None:
|
|
langs = [anki.lang.currentLang]
|
|
|
|
init_msg = pb.BackendInit(
|
|
locale_folder_path=ftl_folder, preferred_langs=langs, server=server,
|
|
)
|
|
self._backend = ankirspy.open_backend(init_msg.SerializeToString())
|
|
self._backend.set_progress_callback(_on_progress)
|
|
|
|
def db_query(
|
|
self, sql: str, args: Sequence[ValueForDB], first_row_only: bool
|
|
) -> List[DBRow]:
|
|
return self._db_command(
|
|
dict(kind="query", sql=sql, args=args, first_row_only=first_row_only)
|
|
)
|
|
|
|
def db_execute_many(self, sql: str, args: List[List[ValueForDB]]) -> List[DBRow]:
|
|
return self._db_command(dict(kind="executemany", sql=sql, args=args))
|
|
|
|
def db_begin(self) -> None:
|
|
return self._db_command(dict(kind="begin"))
|
|
|
|
def db_commit(self) -> None:
|
|
return self._db_command(dict(kind="commit"))
|
|
|
|
def db_rollback(self) -> None:
|
|
return self._db_command(dict(kind="rollback"))
|
|
|
|
def _db_command(self, input: Dict[str, Any]) -> Any:
|
|
return from_json_bytes(self._backend.db_command(to_json_bytes(input)))
|
|
|
|
def translate(self, key: TR, **kwargs: Union[str, int, float]) -> str:
|
|
return self.translate_string(translate_string_in(key, **kwargs))
|
|
|
|
def format_time_span(
|
|
self,
|
|
seconds: float,
|
|
context: FormatTimeSpanContext = FormatTimeSpanContext.INTERVALS,
|
|
) -> str:
|
|
print(
|
|
"please use col.format_timespan() instead of col.backend.format_time_span()"
|
|
)
|
|
return self.format_timespan(seconds=seconds, context=context)
|
|
|
|
def _run_command(self, method: int, input: Any) -> bytes:
|
|
input_bytes = input.SerializeToString()
|
|
try:
|
|
return self._backend.command(method, input_bytes)
|
|
except Exception as e:
|
|
err_bytes = bytes(e.args[0])
|
|
err = pb.BackendError()
|
|
err.ParseFromString(err_bytes)
|
|
raise proto_exception_to_native(err)
|
|
|
|
# The code in this section is automatically generated - any edits you make
|
|
# will be lost.
|
|
|
|
# @@AUTOGEN@@
|
|
|
|
def extract_av_tags(self, *, text: str, question_side: bool) -> pb.ExtractAVTagsOut:
|
|
input = pb.ExtractAVTagsIn(text=text, question_side=question_side)
|
|
output = pb.ExtractAVTagsOut()
|
|
output.ParseFromString(self._run_command(1, input))
|
|
return output
|
|
|
|
def extract_latex(
|
|
self, *, text: str, svg: bool, expand_clozes: bool
|
|
) -> pb.ExtractLatexOut:
|
|
input = pb.ExtractLatexIn(text=text, svg=svg, expand_clozes=expand_clozes)
|
|
output = pb.ExtractLatexOut()
|
|
output.ParseFromString(self._run_command(2, input))
|
|
return output
|
|
|
|
def get_empty_cards(self) -> pb.EmptyCardsReport:
|
|
input = pb.Empty()
|
|
output = pb.EmptyCardsReport()
|
|
output.ParseFromString(self._run_command(3, input))
|
|
return output
|
|
|
|
def render_existing_card(self, *, card_id: int, browser: bool) -> pb.RenderCardOut:
|
|
input = pb.RenderExistingCardIn(card_id=card_id, browser=browser)
|
|
output = pb.RenderCardOut()
|
|
output.ParseFromString(self._run_command(4, input))
|
|
return output
|
|
|
|
def render_uncommitted_card(
|
|
self, *, note: pb.Note, card_ord: int, template: bytes, fill_empty: bool
|
|
) -> pb.RenderCardOut:
|
|
input = pb.RenderUncommittedCardIn(
|
|
note=note, card_ord=card_ord, template=template, fill_empty=fill_empty
|
|
)
|
|
output = pb.RenderCardOut()
|
|
output.ParseFromString(self._run_command(5, input))
|
|
return output
|
|
|
|
def strip_av_tags(self, val: str) -> str:
|
|
input = pb.String(val=val)
|
|
output = pb.String()
|
|
output.ParseFromString(self._run_command(6, input))
|
|
return output.val
|
|
|
|
def search_cards(self, *, search: str, order: pb.SortOrder) -> Sequence[int]:
|
|
input = pb.SearchCardsIn(search=search, order=order)
|
|
output = pb.SearchCardsOut()
|
|
output.ParseFromString(self._run_command(7, input))
|
|
return output.card_ids
|
|
|
|
def search_notes(self, search: str) -> Sequence[int]:
|
|
input = pb.SearchNotesIn(search=search)
|
|
output = pb.SearchNotesOut()
|
|
output.ParseFromString(self._run_command(8, input))
|
|
return output.note_ids
|
|
|
|
def find_and_replace(
|
|
self,
|
|
*,
|
|
nids: Sequence[int],
|
|
search: str,
|
|
replacement: str,
|
|
regex: bool,
|
|
match_case: bool,
|
|
field_name: str,
|
|
) -> int:
|
|
input = pb.FindAndReplaceIn(
|
|
nids=nids,
|
|
search=search,
|
|
replacement=replacement,
|
|
regex=regex,
|
|
match_case=match_case,
|
|
field_name=field_name,
|
|
)
|
|
output = pb.UInt32()
|
|
output.ParseFromString(self._run_command(9, input))
|
|
return output.val
|
|
|
|
def local_minutes_west(self, val: int) -> int:
|
|
input = pb.Int64(val=val)
|
|
output = pb.Int32()
|
|
output.ParseFromString(self._run_command(10, input))
|
|
return output.val
|
|
|
|
def set_local_minutes_west(self, val: int) -> pb.Empty:
|
|
input = pb.Int32(val=val)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(11, input))
|
|
return output
|
|
|
|
def sched_timing_today(self) -> pb.SchedTimingTodayOut:
|
|
input = pb.Empty()
|
|
output = pb.SchedTimingTodayOut()
|
|
output.ParseFromString(self._run_command(12, input))
|
|
return output
|
|
|
|
def studied_today(self, *, cards: int, seconds: float) -> str:
|
|
input = pb.StudiedTodayIn(cards=cards, seconds=seconds)
|
|
output = pb.String()
|
|
output.ParseFromString(self._run_command(13, input))
|
|
return output.val
|
|
|
|
def congrats_learn_message(self, *, next_due: float, remaining: int) -> str:
|
|
input = pb.CongratsLearnMessageIn(next_due=next_due, remaining=remaining)
|
|
output = pb.String()
|
|
output.ParseFromString(self._run_command(14, input))
|
|
return output.val
|
|
|
|
def check_media(self) -> pb.CheckMediaOut:
|
|
input = pb.Empty()
|
|
output = pb.CheckMediaOut()
|
|
output.ParseFromString(self._run_command(15, input))
|
|
return output
|
|
|
|
def trash_media_files(self, fnames: Sequence[str]) -> pb.Empty:
|
|
input = pb.TrashMediaFilesIn(fnames=fnames)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(16, input))
|
|
return output
|
|
|
|
def add_media_file(self, *, desired_name: str, data: bytes) -> str:
|
|
input = pb.AddMediaFileIn(desired_name=desired_name, data=data)
|
|
output = pb.String()
|
|
output.ParseFromString(self._run_command(17, input))
|
|
return output.val
|
|
|
|
def empty_trash(self) -> pb.Empty:
|
|
input = pb.Empty()
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(18, input))
|
|
return output
|
|
|
|
def restore_trash(self) -> pb.Empty:
|
|
input = pb.Empty()
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(19, input))
|
|
return output
|
|
|
|
def add_or_update_deck_legacy(
|
|
self, *, deck: bytes, preserve_usn_and_mtime: bool
|
|
) -> int:
|
|
input = pb.AddOrUpdateDeckLegacyIn(
|
|
deck=deck, preserve_usn_and_mtime=preserve_usn_and_mtime
|
|
)
|
|
output = pb.DeckID()
|
|
output.ParseFromString(self._run_command(20, input))
|
|
return output.did
|
|
|
|
def deck_tree(self, *, include_counts: bool, top_deck_id: int) -> pb.DeckTreeNode:
|
|
input = pb.DeckTreeIn(include_counts=include_counts, top_deck_id=top_deck_id)
|
|
output = pb.DeckTreeNode()
|
|
output.ParseFromString(self._run_command(21, input))
|
|
return output
|
|
|
|
def deck_tree_legacy(self) -> bytes:
|
|
input = pb.Empty()
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(22, input))
|
|
return output.json
|
|
|
|
def get_all_decks_legacy(self) -> bytes:
|
|
input = pb.Empty()
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(23, input))
|
|
return output.json
|
|
|
|
def get_deck_id_by_name(self, val: str) -> int:
|
|
input = pb.String(val=val)
|
|
output = pb.DeckID()
|
|
output.ParseFromString(self._run_command(24, input))
|
|
return output.did
|
|
|
|
def get_deck_legacy(self, did: int) -> bytes:
|
|
input = pb.DeckID(did=did)
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(25, input))
|
|
return output.json
|
|
|
|
def get_deck_names(
|
|
self, *, skip_empty_default: bool, include_filtered: bool
|
|
) -> Sequence[pb.DeckNameID]:
|
|
input = pb.GetDeckNamesIn(
|
|
skip_empty_default=skip_empty_default, include_filtered=include_filtered
|
|
)
|
|
output = pb.DeckNames()
|
|
output.ParseFromString(self._run_command(26, input))
|
|
return output.entries
|
|
|
|
def new_deck_legacy(self, val: bool) -> bytes:
|
|
input = pb.Bool(val=val)
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(27, input))
|
|
return output.json
|
|
|
|
def remove_deck(self, did: int) -> pb.Empty:
|
|
input = pb.DeckID(did=did)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(28, input))
|
|
return output
|
|
|
|
def add_or_update_deck_config_legacy(
|
|
self, *, config: bytes, preserve_usn_and_mtime: bool
|
|
) -> int:
|
|
input = pb.AddOrUpdateDeckConfigLegacyIn(
|
|
config=config, preserve_usn_and_mtime=preserve_usn_and_mtime
|
|
)
|
|
output = pb.DeckConfigID()
|
|
output.ParseFromString(self._run_command(29, input))
|
|
return output.dcid
|
|
|
|
def all_deck_config_legacy(self) -> bytes:
|
|
input = pb.Empty()
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(30, input))
|
|
return output.json
|
|
|
|
def get_deck_config_legacy(self, dcid: int) -> bytes:
|
|
input = pb.DeckConfigID(dcid=dcid)
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(31, input))
|
|
return output.json
|
|
|
|
def new_deck_config_legacy(self) -> bytes:
|
|
input = pb.Empty()
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(32, input))
|
|
return output.json
|
|
|
|
def remove_deck_config(self, dcid: int) -> pb.Empty:
|
|
input = pb.DeckConfigID(dcid=dcid)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(33, input))
|
|
return output
|
|
|
|
def get_card(self, cid: int) -> pb.Card:
|
|
input = pb.CardID(cid=cid)
|
|
output = pb.Card()
|
|
output.ParseFromString(self._run_command(34, input))
|
|
return output
|
|
|
|
def update_card(self, input: pb.Card) -> pb.Empty:
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(35, input))
|
|
return output
|
|
|
|
def add_card(self, input: pb.Card) -> int:
|
|
output = pb.CardID()
|
|
output.ParseFromString(self._run_command(36, input))
|
|
return output.cid
|
|
|
|
def new_note(self, ntid: int) -> pb.Note:
|
|
input = pb.NoteTypeID(ntid=ntid)
|
|
output = pb.Note()
|
|
output.ParseFromString(self._run_command(37, input))
|
|
return output
|
|
|
|
def add_note(self, *, note: pb.Note, deck_id: int) -> int:
|
|
input = pb.AddNoteIn(note=note, deck_id=deck_id)
|
|
output = pb.NoteID()
|
|
output.ParseFromString(self._run_command(38, input))
|
|
return output.nid
|
|
|
|
def update_note(self, input: pb.Note) -> pb.Empty:
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(39, input))
|
|
return output
|
|
|
|
def get_note(self, nid: int) -> pb.Note:
|
|
input = pb.NoteID(nid=nid)
|
|
output = pb.Note()
|
|
output.ParseFromString(self._run_command(40, input))
|
|
return output
|
|
|
|
def add_note_tags(self, *, nids: Sequence[int], tags: str) -> int:
|
|
input = pb.AddNoteTagsIn(nids=nids, tags=tags)
|
|
output = pb.UInt32()
|
|
output.ParseFromString(self._run_command(41, input))
|
|
return output.val
|
|
|
|
def update_note_tags(
|
|
self, *, nids: Sequence[int], tags: str, replacement: str, regex: bool
|
|
) -> int:
|
|
input = pb.UpdateNoteTagsIn(
|
|
nids=nids, tags=tags, replacement=replacement, regex=regex
|
|
)
|
|
output = pb.UInt32()
|
|
output.ParseFromString(self._run_command(42, input))
|
|
return output.val
|
|
|
|
def cloze_numbers_in_note(self, input: pb.Note) -> Sequence[int]:
|
|
output = pb.ClozeNumbersInNoteOut()
|
|
output.ParseFromString(self._run_command(43, input))
|
|
return output.numbers
|
|
|
|
def after_note_updates(
|
|
self, *, nids: Sequence[int], mark_notes_modified: bool, generate_cards: bool
|
|
) -> pb.Empty:
|
|
input = pb.AfterNoteUpdatesIn(
|
|
nids=nids,
|
|
mark_notes_modified=mark_notes_modified,
|
|
generate_cards=generate_cards,
|
|
)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(44, input))
|
|
return output
|
|
|
|
def field_names_for_notes(self, nids: Sequence[int]) -> Sequence[str]:
|
|
input = pb.FieldNamesForNotesIn(nids=nids)
|
|
output = pb.FieldNamesForNotesOut()
|
|
output.ParseFromString(self._run_command(45, input))
|
|
return output.fields
|
|
|
|
def note_is_duplicate_or_empty(
|
|
self, input: pb.Note
|
|
) -> pb.NoteIsDuplicateOrEmptyOut.State:
|
|
output = pb.NoteIsDuplicateOrEmptyOut()
|
|
output.ParseFromString(self._run_command(46, input))
|
|
return output.state
|
|
|
|
def add_or_update_notetype(
|
|
self, *, json: bytes, preserve_usn_and_mtime: bool
|
|
) -> int:
|
|
input = pb.AddOrUpdateNotetypeIn(
|
|
json=json, preserve_usn_and_mtime=preserve_usn_and_mtime
|
|
)
|
|
output = pb.NoteTypeID()
|
|
output.ParseFromString(self._run_command(47, input))
|
|
return output.ntid
|
|
|
|
def get_stock_notetype_legacy(self, kind: pb.StockNoteType) -> bytes:
|
|
input = pb.GetStockNotetypeIn(kind=kind)
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(48, input))
|
|
return output.json
|
|
|
|
def get_notetype_legacy(self, ntid: int) -> bytes:
|
|
input = pb.NoteTypeID(ntid=ntid)
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(49, input))
|
|
return output.json
|
|
|
|
def get_notetype_names(self) -> Sequence[pb.NoteTypeNameID]:
|
|
input = pb.Empty()
|
|
output = pb.NoteTypeNames()
|
|
output.ParseFromString(self._run_command(50, input))
|
|
return output.entries
|
|
|
|
def get_notetype_names_and_counts(self) -> Sequence[pb.NoteTypeNameIDUseCount]:
|
|
input = pb.Empty()
|
|
output = pb.NoteTypeUseCounts()
|
|
output.ParseFromString(self._run_command(51, input))
|
|
return output.entries
|
|
|
|
def get_notetype_id_by_name(self, val: str) -> int:
|
|
input = pb.String(val=val)
|
|
output = pb.NoteTypeID()
|
|
output.ParseFromString(self._run_command(52, input))
|
|
return output.ntid
|
|
|
|
def remove_notetype(self, ntid: int) -> pb.Empty:
|
|
input = pb.NoteTypeID(ntid=ntid)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(53, input))
|
|
return output
|
|
|
|
def open_collection(
|
|
self,
|
|
*,
|
|
collection_path: str,
|
|
media_folder_path: str,
|
|
media_db_path: str,
|
|
log_path: str,
|
|
) -> pb.Empty:
|
|
input = pb.OpenCollectionIn(
|
|
collection_path=collection_path,
|
|
media_folder_path=media_folder_path,
|
|
media_db_path=media_db_path,
|
|
log_path=log_path,
|
|
)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(54, input))
|
|
return output
|
|
|
|
def close_collection(self, downgrade_to_schema11: bool) -> pb.Empty:
|
|
input = pb.CloseCollectionIn(downgrade_to_schema11=downgrade_to_schema11)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(55, input))
|
|
return output
|
|
|
|
def check_database(self) -> Sequence[str]:
|
|
input = pb.Empty()
|
|
output = pb.CheckDatabaseOut()
|
|
output.ParseFromString(self._run_command(56, input))
|
|
return output.problems
|
|
|
|
def sync_media(self, *, hkey: str, endpoint: str) -> pb.Empty:
|
|
input = pb.SyncMediaIn(hkey=hkey, endpoint=endpoint)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(57, input))
|
|
return output
|
|
|
|
def abort_media_sync(self) -> pb.Empty:
|
|
input = pb.Empty()
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(58, input))
|
|
return output
|
|
|
|
def before_upload(self) -> pb.Empty:
|
|
input = pb.Empty()
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(59, input))
|
|
return output
|
|
|
|
def translate_string(self, input: pb.TranslateStringIn) -> str:
|
|
output = pb.String()
|
|
output.ParseFromString(self._run_command(60, input))
|
|
return output.val
|
|
|
|
def format_timespan(
|
|
self, *, seconds: float, context: pb.FormatTimespanIn.Context
|
|
) -> str:
|
|
input = pb.FormatTimespanIn(seconds=seconds, context=context)
|
|
output = pb.String()
|
|
output.ParseFromString(self._run_command(61, input))
|
|
return output.val
|
|
|
|
def register_tags(
|
|
self, *, tags: str, preserve_usn: bool, usn: int, clear_first: bool
|
|
) -> bool:
|
|
input = pb.RegisterTagsIn(
|
|
tags=tags, preserve_usn=preserve_usn, usn=usn, clear_first=clear_first
|
|
)
|
|
output = pb.Bool()
|
|
output.ParseFromString(self._run_command(62, input))
|
|
return output.val
|
|
|
|
def all_tags(self) -> Sequence[pb.TagUsnTuple]:
|
|
input = pb.Empty()
|
|
output = pb.AllTagsOut()
|
|
output.ParseFromString(self._run_command(63, input))
|
|
return output.tags
|
|
|
|
def get_changed_tags(self, val: int) -> Sequence[str]:
|
|
input = pb.Int32(val=val)
|
|
output = pb.GetChangedTagsOut()
|
|
output.ParseFromString(self._run_command(64, input))
|
|
return output.tags
|
|
|
|
def get_config_json(self, val: str) -> bytes:
|
|
input = pb.String(val=val)
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(65, input))
|
|
return output.json
|
|
|
|
def set_config_json(self, *, key: str, value_json: bytes) -> pb.Empty:
|
|
input = pb.SetConfigJsonIn(key=key, value_json=value_json)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(66, input))
|
|
return output
|
|
|
|
def remove_config(self, val: str) -> pb.Empty:
|
|
input = pb.String(val=val)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(67, input))
|
|
return output
|
|
|
|
def set_all_config(self, json: bytes) -> pb.Empty:
|
|
input = pb.Json(json=json)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(68, input))
|
|
return output
|
|
|
|
def get_all_config(self) -> bytes:
|
|
input = pb.Empty()
|
|
output = pb.Json()
|
|
output.ParseFromString(self._run_command(69, input))
|
|
return output.json
|
|
|
|
def get_preferences(self) -> pb.CollectionSchedulingSettings:
|
|
input = pb.Empty()
|
|
output = pb.Preferences()
|
|
output.ParseFromString(self._run_command(70, input))
|
|
return output.sched
|
|
|
|
def set_preferences(self, sched: pb.CollectionSchedulingSettings) -> pb.Empty:
|
|
input = pb.Preferences(sched=sched)
|
|
output = pb.Empty()
|
|
output.ParseFromString(self._run_command(71, input))
|
|
return output
|
|
|
|
# @@AUTOGEN@@
|
|
|
|
|
|
def translate_string_in(
|
|
key: TR, **kwargs: Union[str, int, float]
|
|
) -> pb.TranslateStringIn:
|
|
args = {}
|
|
for (k, v) in kwargs.items():
|
|
if isinstance(v, str):
|
|
args[k] = pb.TranslateArgValue(str=v)
|
|
else:
|
|
args[k] = pb.TranslateArgValue(number=v)
|
|
return pb.TranslateStringIn(key=key, args=args)
|
|
|
|
|
|
# temporarily force logging of media handling
|
|
if "RUST_LOG" not in os.environ:
|
|
os.environ["RUST_LOG"] = "warn,anki::media=debug,anki::dbcheck=debug"
|