5f9451f547
* Add apkg export on backend * Filter out missing media-paths at write time * Make TagMatcher::new() infallible * Gather export data instead of copying directly * Revert changes to rslib/src/tags/ * Reuse filename_is_safe/check_filename_safe() * Accept func to produce MediaIter in export_apkg() * Only store file folder once in MediaIter * Use temporary tables for gathering export_apkg() now accepts a search instead of a deck id. Decks are gathered according to the matched notes' cards. * Use schedule_as_new() to reset cards * ExportData → ExchangeData * Ignore ascii case when filtering system tags * search_notes_cards_into_table → search_cards_of_notes_into_table * Start on apkg importing on backend * Fix due dates in days for apkg export * Refactor import-export/package - Move media and meta code into appropriate modules. - Normalize/check for normalization when deserializing media entries. * Add SafeMediaEntry for deserialized MediaEntries * Prepare media based on checksums - Ensure all existing media files are hashed. - Hash incoming files during preparation to detect conflicts. - Uniquify names of conflicting files with hash (not notetype id). - Mark media files as used while importing notes. - Finally copy used media. * Handle encoding in `replace_media_refs()` * Add trait to keep down cow boilerplate * Add notetypes immediately instaed of preparing * Move target_col into Context * Add notes immediately instaed of preparing * Note id, not guid of conflicting notes * Add import_decks() * decks_configs → deck_configs * Add import_deck_configs() * Add import_cards(), import_revlog() * Use dyn instead of generic for media_fn Otherwise, would have to pass None with type annotation in the default case. * Fix signature of import_apkg() * Fix search_cards_of_notes_into_table() * Test new functions in text.rs * Add roundtrip test for apkg (stub) * Keep source id of imported cards (or skip) * Keep source ids of imported revlog (or skip) * Try to keep source ids of imported notes * Make adding notetype with id undoable * Wrap apkg import in transaction * Keep source ids of imported deck configs (or skip) * Handle card due dates and original due/did * Fix importing cards/revlog Card ids are manually uniquified. * Factor out card importing * Refactor card and revlog importing * Factor out card importing Also handle missing parents . * Factor out note importing * Factor out media importing * Maybe upgrade scheduler of apkg * Fix parent deck gathering * Unconditionally import static media * Fix deck importing edge cases Test those edge cases, and add some global test helpers. * Test note importing * Let import_apkg() take a progress func * Expand roundtrip apkg test * Use fat pointer to avoid propogating generics * Fix progress_fn type * Expose apkg export/import on backend * Return note log when importing apkg * Fix archived collection name on apkg import * Add CollectionOpWithBackendProgress * Fix wrong Interrupted Exception being checked * Add ClosedCollectionOp * Add note ids to log and strip HTML * Update progress when checking incoming media too * Conditionally enable new importing in GUI * Fix all_checksums() for media import Entries of deleted files are nulled, not removed. * Make apkg exporting on backend abortable * Return number of notes imported from apkg * Fix exception printing for QueryOp as well * Add QueryOpWithBackendProgress Also support backend exporting progress. * Expose new apkg and colpkg exporting * Open transaction in insert_data() Was slowing down exporting by several orders of magnitude. * Handle zstd-compressed apkg * Add legacy arg to ExportAnkiPackage Currently not exposed on the frontend * Remove unused import in proto file * Add symlink for typechecking of import_export_pb2 * Avoid kwargs in pb message creation, so typechecking is not lost Protobuf's behaviour is rather subtle and I had to dig through the docs to figure it out: set a field on a submessage to automatically assign the submessage to the parent, or call SetInParent() to persist a default version of the field you specified. * Avoid re-exporting protobuf msgs we only use internally * Stop after one test failure mypy often fails much faster than pylint * Avoid an extra allocation when extracting media checksums * Update progress after prepare_media() finishes Otherwise the bulk of the import ends up being shown as "Checked: 0" in the progress window. * Show progress of note imports Note import is the slowest part, so showing progress here makes the UI feel more responsive. * Reset filtered decks at import time Before this change, filtered decks exported with scheduling remained filtered on import, and maybe_remove_from_filtered_deck() moved cards into them as their home deck, leading to errors during review. We may still want to provide a way to preserve filtered decks on import, but to do that we'll need to ensure we don't rewrite the home decks of cards, and we'll need to ensure the home decks are included as part of the import (or give an error if they're not). https://github.com/ankitects/anki/pull/1743/files#r839346423 * Fix a corner-case where due dates were shifted by a day This issue existed in the old Python code as well. We need to include the user's UTC offset in the exported file, or days_elapsed falls back on the v1 cutoff calculation, which may be a day earlier or later than the v2 calculation. * Log conflicting note in remapped nt case * take_fields() → into_fields() * Alias `[u8; 20]` with `Sha1Hash` * Truncate logged fields * Rework apkg note import tests - Use macros for more helpful errors. - Split monolith into unit tests. - Fix some unknown error with the previous test along the way. (Was failing after 969484de4388d225c9f17d94534b3ba0094c3568.) * Fix sorting of imported decks Also adjust the test, so it fails without the patch. It was only passing before, because the parent deck happened to come before the inconsistently capitalised child alphabetically. But we want all parent decks to be imported before their child decks, so their children can adopt their capitalisation. * target[_id]s → existing_card[_id]s * export_collection_extracting_media() → ... export_into_collection_file() * target_already_exists→card_ordinal_already_exists * Add search_cards_of_notes_into_table.sql * Imrove type of apkg export selector/limit * Remove redundant call to mod_schema() * Parent tooltips to mw * Fix a crash when truncating note text String::truncate() is a bit of a footgun, and I've hit this before too :-) * Remove ExportLimit in favour of separate classes * Remove OpWithBackendProgress and ClosedCollectionOp Backend progress logic is now in ProgressManager. QueryOp can be used for running on closed collection. Also fix aborting of colpkg exports, which slipped through in #1817. * Tidy up import log * Avoid QDialog.exec() * Default to excluding scheuling for deck list deck * Use IncrementalProgress in whole import_export code * Compare checksums when importing colpkgs * Avoid registering changes if hashes are not needed * ImportProgress::Collection → ImportProgress::File * Make downgrading apkgs depend on meta version * Generalise IncrementableProgress And use it in entire import_export code instead. * Fix type complexity lint * Take count_map for IncrementableProgress::get_inner * Replace import/export env with Shift click * Accept all args from update() for backend progress * Pass fields of ProgressUpdate explicitly * Move update_interval into IncrementableProgress * Outsource incrementing into Incrementor * Mutate ProgressUpdate in progress_update callback * Switch import/export legacy toggle to profile setting Shift would have been nice, but the existing shortcuts complicate things. If the user triggers an import with ctrl+shift+i, shift is unlikely to have been released by the time our code runs, meaning the user accidentally triggers the new code. We could potentially wait a while before bringing up the dialog, but then we're forced to guess at how long it will take the user to release the key. One alternative would be to use alt instead of shift, but then we need to trigger our shortcut when that key is pressed as well, and it could potentially cause a conflict with an add-on that already uses that combination. * Show extension in export dialog * Continue to provide separate options for schema 11+18 colpkg export * Default to colpkg export when using File>Export * Improve appearance of combo boxes when switching between apkg/colpkg + Deal with long deck names * Convert newlines to spaces when showing fields from import Ensures each imported note appears on a separate line * Don't separate total note count from the other summary lines This may come down to personal preference, but I feel the other counts are equally as important, and separating them feels like it makes it a bit easier to ignore them. * Fix 'deck not normal' error when importing a filtered deck for the 2nd time * Fix [Identical] being shown on first import * Revert "Continue to provide separate options for schema 11+18 colpkg export" This reverts commit 8f0b2c175f4794d642823b60414d142a12768441. Will use a different approach * Move legacy support into a separate exporter option; add to apkg export * Adjust 'too new' message to also apply to .apkg import case * Show a better message when attempting to import new apkg into old code Previously the user could end seeing a message like: UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb5 in position 1: invalid start byte Unfortunately we can't retroactively fix this for older clients. * Hide legacy support option in older exporting screen * Reflect change from paths to fnames in type & name * Make imported decks normal at once Then skip special casing in update_deck(). Also skip updating description if new one is empty. Co-authored-by: Damien Elmes <gpg@ankiweb.net>
587 lines
19 KiB
Python
587 lines
19 KiB
Python
# Copyright: Ankitects Pty Ltd and contributors
|
|
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
|
|
from __future__ import annotations
|
|
|
|
import io
|
|
import pickle
|
|
import random
|
|
import shutil
|
|
import traceback
|
|
from enum import Enum
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import anki.lang
|
|
import aqt.forms
|
|
import aqt.sound
|
|
from anki.collection import Collection
|
|
from anki.db import DB
|
|
from anki.lang import without_unicode_isolation
|
|
from anki.sync import SyncAuth
|
|
from anki.utils import int_time, is_mac, is_win, point_version
|
|
from aqt import appHelpSite
|
|
from aqt.qt import *
|
|
from aqt.theme import Theme
|
|
from aqt.utils import disable_help_button, send_to_trash, showWarning, tr
|
|
|
|
# Profile handling
|
|
##########################################################################
|
|
# - Saves in pickles rather than json to easily store Qt window state.
|
|
# - Saves in sqlite rather than a flat file so the config can't be corrupted
|
|
|
|
|
|
class VideoDriver(Enum):
|
|
OpenGL = "auto"
|
|
ANGLE = "angle"
|
|
Software = "software"
|
|
|
|
@staticmethod
|
|
def default_for_platform() -> VideoDriver:
|
|
if is_mac or qtmajor > 5:
|
|
return VideoDriver.OpenGL
|
|
else:
|
|
return VideoDriver.Software
|
|
|
|
def constrained_to_platform(self) -> VideoDriver:
|
|
if self == VideoDriver.ANGLE and not VideoDriver.supports_angle():
|
|
return VideoDriver.Software
|
|
return self
|
|
|
|
def next(self) -> VideoDriver:
|
|
if self == VideoDriver.Software:
|
|
return VideoDriver.OpenGL
|
|
elif self == VideoDriver.OpenGL and VideoDriver.supports_angle():
|
|
return VideoDriver.ANGLE
|
|
else:
|
|
return VideoDriver.Software
|
|
|
|
@staticmethod
|
|
def supports_angle() -> bool:
|
|
return is_win and qtmajor < 6
|
|
|
|
@staticmethod
|
|
def all_for_platform() -> list[VideoDriver]:
|
|
all = [VideoDriver.OpenGL]
|
|
if VideoDriver.supports_angle():
|
|
all.append(VideoDriver.ANGLE)
|
|
all.append(VideoDriver.Software)
|
|
return all
|
|
|
|
|
|
metaConf = dict(
|
|
ver=0,
|
|
updates=True,
|
|
created=int_time(),
|
|
id=random.randrange(0, 2**63),
|
|
lastMsg=-1,
|
|
suppressUpdate=False,
|
|
firstRun=True,
|
|
defaultLang=None,
|
|
)
|
|
|
|
profileConf: dict[str, Any] = dict(
|
|
# profile
|
|
mainWindowGeom=None,
|
|
mainWindowState=None,
|
|
numBackups=50,
|
|
lastOptimize=int_time(),
|
|
# editing
|
|
searchHistory=[],
|
|
lastTextColor="#00f",
|
|
lastHighlightColor="#00f",
|
|
# syncing
|
|
syncKey=None,
|
|
syncMedia=True,
|
|
autoSync=True,
|
|
# importing
|
|
allowHTML=False,
|
|
importMode=1,
|
|
# these are not used, but Anki 2.1.42 and below
|
|
# expect these keys to exist
|
|
lastColour="#00f",
|
|
stripHTML=True,
|
|
deleteMedia=False,
|
|
)
|
|
|
|
|
|
class LoadMetaResult:
|
|
firstTime: bool
|
|
loadError: bool
|
|
|
|
|
|
class ProfileManager:
|
|
def __init__(self, base: str | None = None) -> None: #
|
|
## Settings which should be forgotten each Anki restart
|
|
self.session: dict[str, Any] = {}
|
|
self.name: str | None = None
|
|
self.db: DB | None = None
|
|
self.profile: dict | None = None
|
|
# instantiate base folder
|
|
self.base: str
|
|
self._setBaseFolder(base)
|
|
|
|
def setupMeta(self) -> LoadMetaResult:
|
|
# load metadata
|
|
res = self._loadMeta()
|
|
self.firstRun = res.firstTime
|
|
return res
|
|
|
|
# profile load on startup
|
|
def openProfile(self, profile: str) -> None:
|
|
if profile:
|
|
if profile not in self.profiles():
|
|
QMessageBox.critical(
|
|
None, tr.qt_misc_error(), tr.profiles_profile_does_not_exist()
|
|
)
|
|
sys.exit(1)
|
|
try:
|
|
self.load(profile)
|
|
except TypeError as exc:
|
|
raise Exception("Provided profile does not exist.") from exc
|
|
|
|
# Base creation
|
|
######################################################################
|
|
|
|
def ensureBaseExists(self) -> None:
|
|
self._ensureExists(self.base)
|
|
|
|
# Profile load/save
|
|
######################################################################
|
|
|
|
def profiles(self) -> list:
|
|
def names() -> list:
|
|
return self.db.list("select name from profiles where name != '_global'")
|
|
|
|
n = names()
|
|
if not n:
|
|
self._ensureProfile()
|
|
n = names()
|
|
|
|
return n
|
|
|
|
def _unpickle(self, data: bytes) -> Any:
|
|
class Unpickler(pickle.Unpickler):
|
|
def find_class(self, class_module: str, name: str) -> Any:
|
|
# handle sip lookup ourselves, mapping to current Qt version
|
|
if class_module == "sip" or class_module.endswith(".sip"):
|
|
|
|
def unpickle_type(module: str, klass: str, args: Any) -> Any:
|
|
if qtmajor > 5:
|
|
module = module.replace("Qt5", "Qt6")
|
|
else:
|
|
module = module.replace("Qt6", "Qt5")
|
|
if klass == "QByteArray":
|
|
if module.startswith("PyQt4"):
|
|
# can't trust str objects from python 2
|
|
return QByteArray()
|
|
else:
|
|
# return the bytes directly
|
|
return args[0]
|
|
elif name == "_unpickle_enum":
|
|
if qtmajor == 5:
|
|
return sip._unpickle_enum(module, klass, args) # type: ignore
|
|
else:
|
|
# old style enums can't be unpickled
|
|
return None
|
|
else:
|
|
return sip._unpickle_type(module, klass, args) # type: ignore
|
|
|
|
return unpickle_type
|
|
else:
|
|
return super().find_class(class_module, name)
|
|
|
|
up = Unpickler(io.BytesIO(data), errors="ignore")
|
|
return up.load()
|
|
|
|
def _pickle(self, obj: Any) -> bytes:
|
|
for key, val in obj.items():
|
|
if isinstance(val, QByteArray):
|
|
obj[key] = bytes(val) # type: ignore
|
|
|
|
return pickle.dumps(obj, protocol=4)
|
|
|
|
def load(self, name: str) -> bool:
|
|
if name == "_global":
|
|
raise Exception("_global is not a valid name")
|
|
data = self.db.scalar(
|
|
"select cast(data as blob) from profiles where name = ?", name
|
|
)
|
|
self.name = name
|
|
try:
|
|
self.profile = self._unpickle(data)
|
|
except:
|
|
print(traceback.format_exc())
|
|
QMessageBox.warning(
|
|
None,
|
|
tr.profiles_profile_corrupt(),
|
|
tr.profiles_anki_could_not_read_your_profile(),
|
|
)
|
|
print("resetting corrupt profile")
|
|
self.profile = profileConf.copy()
|
|
self.save()
|
|
return True
|
|
|
|
def save(self) -> None:
|
|
sql = "update profiles set data = ? where name = ?"
|
|
self.db.execute(sql, self._pickle(self.profile), self.name)
|
|
self.db.execute(sql, self._pickle(self.meta), "_global")
|
|
self.db.commit()
|
|
|
|
def create(self, name: str) -> None:
|
|
prof = profileConf.copy()
|
|
self.db.execute(
|
|
"insert or ignore into profiles values (?, ?)", name, self._pickle(prof)
|
|
)
|
|
self.db.commit()
|
|
|
|
def remove(self, name: str) -> None:
|
|
path = self.profileFolder(create=False)
|
|
send_to_trash(Path(path))
|
|
self.db.execute("delete from profiles where name = ?", name)
|
|
self.db.commit()
|
|
|
|
def trashCollection(self) -> None:
|
|
path = self.collectionPath()
|
|
send_to_trash(Path(path))
|
|
|
|
def rename(self, name: str) -> None:
|
|
oldName = self.name
|
|
oldFolder = self.profileFolder()
|
|
self.name = name
|
|
newFolder = self.profileFolder(create=False)
|
|
if os.path.exists(newFolder):
|
|
if (oldFolder != newFolder) and (oldFolder.lower() == newFolder.lower()):
|
|
# OS is telling us the folder exists because it does not take
|
|
# case into account; use a temporary folder location
|
|
midFolder = "".join([oldFolder, "-temp"])
|
|
if not os.path.exists(midFolder):
|
|
os.rename(oldFolder, midFolder)
|
|
oldFolder = midFolder
|
|
else:
|
|
showWarning(tr.profiles_please_remove_the_folder_and(val=midFolder))
|
|
self.name = oldName
|
|
return
|
|
else:
|
|
showWarning(tr.profiles_folder_already_exists())
|
|
self.name = oldName
|
|
return
|
|
|
|
# update name
|
|
self.db.execute("update profiles set name = ? where name = ?", name, oldName)
|
|
# rename folder
|
|
try:
|
|
os.rename(oldFolder, newFolder)
|
|
except Exception as e:
|
|
self.db.rollback()
|
|
if "WinError 5" in str(e):
|
|
showWarning(tr.profiles_anki_could_not_rename_your_profile())
|
|
else:
|
|
raise
|
|
except:
|
|
self.db.rollback()
|
|
raise
|
|
else:
|
|
self.db.commit()
|
|
|
|
# Folder handling
|
|
######################################################################
|
|
|
|
def profileFolder(self, create: bool = True) -> str:
|
|
path = os.path.join(self.base, self.name)
|
|
if create:
|
|
self._ensureExists(path)
|
|
return path
|
|
|
|
def addonFolder(self) -> str:
|
|
return self._ensureExists(os.path.join(self.base, "addons21"))
|
|
|
|
def backupFolder(self) -> str:
|
|
return self._ensureExists(os.path.join(self.profileFolder(), "backups"))
|
|
|
|
def collectionPath(self) -> str:
|
|
return os.path.join(self.profileFolder(), "collection.anki2")
|
|
|
|
# Downgrade
|
|
######################################################################
|
|
|
|
def downgrade(self, profiles: list[str]) -> list[str]:
|
|
"Downgrade all profiles. Return a list of profiles that couldn't be opened."
|
|
problem_profiles = []
|
|
for name in profiles:
|
|
path = os.path.join(self.base, name, "collection.anki2")
|
|
if not os.path.exists(path):
|
|
continue
|
|
with DB(path) as db:
|
|
if db.scalar("select ver from col") == 11:
|
|
# nothing to do
|
|
continue
|
|
try:
|
|
c = Collection(path)
|
|
c.close(save=False, downgrade=True)
|
|
except Exception as e:
|
|
print(e)
|
|
problem_profiles.append(name)
|
|
return problem_profiles
|
|
|
|
# Helpers
|
|
######################################################################
|
|
|
|
def _ensureExists(self, path: str) -> str:
|
|
if not os.path.exists(path):
|
|
os.makedirs(path)
|
|
return path
|
|
|
|
def _setBaseFolder(self, cmdlineBase: str | None) -> None:
|
|
if cmdlineBase:
|
|
self.base = os.path.abspath(cmdlineBase)
|
|
elif os.environ.get("ANKI_BASE"):
|
|
self.base = os.path.abspath(os.environ["ANKI_BASE"])
|
|
else:
|
|
self.base = self._defaultBase()
|
|
self.ensureBaseExists()
|
|
|
|
def _defaultBase(self) -> str:
|
|
if is_win:
|
|
from aqt.winpaths import get_appdata
|
|
|
|
return os.path.join(get_appdata(), "Anki2")
|
|
elif is_mac:
|
|
return os.path.expanduser("~/Library/Application Support/Anki2")
|
|
else:
|
|
dataDir = os.environ.get(
|
|
"XDG_DATA_HOME", os.path.expanduser("~/.local/share")
|
|
)
|
|
if not os.path.exists(dataDir):
|
|
os.makedirs(dataDir)
|
|
return os.path.join(dataDir, "Anki2")
|
|
|
|
def _loadMeta(self, retrying: bool = False) -> LoadMetaResult:
|
|
result = LoadMetaResult()
|
|
result.firstTime = False
|
|
result.loadError = retrying
|
|
|
|
opath = os.path.join(self.base, "prefs.db")
|
|
path = os.path.join(self.base, "prefs21.db")
|
|
if not retrying and os.path.exists(opath) and not os.path.exists(path):
|
|
shutil.copy(opath, path)
|
|
|
|
result.firstTime = not os.path.exists(path)
|
|
|
|
def recover() -> None:
|
|
# if we can't load profile, start with a new one
|
|
if self.db:
|
|
try:
|
|
self.db.close()
|
|
except:
|
|
pass
|
|
for suffix in ("", "-journal"):
|
|
fpath = path + suffix
|
|
if os.path.exists(fpath):
|
|
os.unlink(fpath)
|
|
|
|
# open DB file and read data
|
|
try:
|
|
self.db = DB(path)
|
|
if not self.db.scalar("pragma integrity_check") == "ok":
|
|
raise Exception("corrupt db")
|
|
self.db.execute(
|
|
"""
|
|
create table if not exists profiles
|
|
(name text primary key, data blob not null);"""
|
|
)
|
|
data = self.db.scalar(
|
|
"select cast(data as blob) from profiles where name = '_global'"
|
|
)
|
|
except:
|
|
traceback.print_stack()
|
|
if result.loadError:
|
|
# already failed, prevent infinite loop
|
|
raise
|
|
# delete files and try again
|
|
recover()
|
|
return self._loadMeta(retrying=True)
|
|
|
|
# try to read data
|
|
if not result.firstTime:
|
|
try:
|
|
self.meta = self._unpickle(data)
|
|
return result
|
|
except:
|
|
traceback.print_stack()
|
|
print("resetting corrupt _global")
|
|
result.loadError = True
|
|
result.firstTime = True
|
|
|
|
# if new or read failed, create a default global profile
|
|
self.meta = metaConf.copy()
|
|
self.db.execute(
|
|
"insert or replace into profiles values ('_global', ?)",
|
|
self._pickle(metaConf),
|
|
)
|
|
return result
|
|
|
|
def _ensureProfile(self) -> None:
|
|
"Create a new profile if none exists."
|
|
self.create(tr.profiles_user_1())
|
|
p = os.path.join(self.base, "README.txt")
|
|
with open(p, "w", encoding="utf8") as file:
|
|
file.write(
|
|
without_unicode_isolation(
|
|
tr.profiles_folder_readme(
|
|
link=f"{appHelpSite}files#startup-options",
|
|
)
|
|
)
|
|
+ "\n"
|
|
)
|
|
|
|
# Default language
|
|
######################################################################
|
|
# On first run, allow the user to choose the default language
|
|
|
|
def setDefaultLang(self, idx: int) -> None:
|
|
# create dialog
|
|
class NoCloseDiag(QDialog):
|
|
def reject(self) -> None:
|
|
pass
|
|
|
|
d = self.langDiag = NoCloseDiag()
|
|
f = self.langForm = aqt.forms.setlang.Ui_Dialog()
|
|
f.setupUi(d)
|
|
disable_help_button(d)
|
|
qconnect(d.accepted, self._onLangSelected)
|
|
qconnect(d.rejected, lambda: True)
|
|
# update list
|
|
f.lang.addItems([x[0] for x in anki.lang.langs])
|
|
f.lang.setCurrentRow(idx)
|
|
d.exec()
|
|
|
|
def _onLangSelected(self) -> None:
|
|
f = self.langForm
|
|
obj = anki.lang.langs[f.lang.currentRow()]
|
|
code = obj[1]
|
|
name = obj[0]
|
|
r = QMessageBox.question(
|
|
None, "Anki", tr.profiles_confirm_lang_choice(lang=name), QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.No # type: ignore
|
|
)
|
|
if r != QMessageBox.StandardButton.Yes:
|
|
return self.setDefaultLang(f.lang.currentRow())
|
|
self.setLang(code)
|
|
|
|
def setLang(self, code: str) -> None:
|
|
self.meta["defaultLang"] = code
|
|
sql = "update profiles set data = ? where name = ?"
|
|
self.db.execute(sql, self._pickle(self.meta), "_global")
|
|
self.db.commit()
|
|
anki.lang.set_lang(code)
|
|
|
|
# OpenGL
|
|
######################################################################
|
|
|
|
def _gldriver_path(self) -> str:
|
|
if qtmajor < 6:
|
|
fname = "gldriver"
|
|
else:
|
|
fname = "gldriver6"
|
|
return os.path.join(self.base, fname)
|
|
|
|
def video_driver(self) -> VideoDriver:
|
|
path = self._gldriver_path()
|
|
try:
|
|
with open(path, encoding="utf8") as file:
|
|
text = file.read().strip()
|
|
return VideoDriver(text).constrained_to_platform()
|
|
except (ValueError, OSError):
|
|
return VideoDriver.default_for_platform()
|
|
|
|
def set_video_driver(self, driver: VideoDriver) -> None:
|
|
with open(self._gldriver_path(), "w", encoding="utf8") as file:
|
|
file.write(driver.value)
|
|
|
|
def set_next_video_driver(self) -> None:
|
|
self.set_video_driver(self.video_driver().next())
|
|
|
|
# Shared options
|
|
######################################################################
|
|
|
|
def last_run_version(self) -> int:
|
|
return self.meta.get("last_run_version", 0)
|
|
|
|
def set_last_run_version(self) -> None:
|
|
self.meta["last_run_version"] = point_version()
|
|
|
|
def uiScale(self) -> float:
|
|
scale = self.meta.get("uiScale", 1.0)
|
|
return max(scale, 1)
|
|
|
|
def setUiScale(self, scale: float) -> None:
|
|
self.meta["uiScale"] = scale
|
|
|
|
def last_addon_update_check(self) -> int:
|
|
return self.meta.get("last_addon_update_check", 0)
|
|
|
|
def set_last_addon_update_check(self, secs: int) -> None:
|
|
self.meta["last_addon_update_check"] = secs
|
|
|
|
def night_mode(self) -> bool:
|
|
return self.meta.get("night_mode", False)
|
|
|
|
def set_night_mode(self, on: bool) -> None:
|
|
self.meta["night_mode"] = on
|
|
|
|
def theme(self) -> Theme:
|
|
return Theme(self.meta.get("theme", 0))
|
|
|
|
def set_theme(self, theme: Theme) -> None:
|
|
self.meta["theme"] = theme.value
|
|
|
|
def dark_mode_widgets(self) -> bool:
|
|
return self.meta.get("dark_mode_widgets", False)
|
|
|
|
def new_import_export(self) -> bool:
|
|
return self.meta.get("new_import_export", False)
|
|
|
|
def set_new_import_export(self, enabled: bool) -> None:
|
|
self.meta["new_import_export"] = enabled
|
|
|
|
# Profile-specific
|
|
######################################################################
|
|
|
|
def set_sync_key(self, val: str | None) -> None:
|
|
self.profile["syncKey"] = val
|
|
|
|
def set_sync_username(self, val: str | None) -> None:
|
|
self.profile["syncUser"] = val
|
|
|
|
def set_host_number(self, val: int | None) -> None:
|
|
self.profile["hostNum"] = val or 0
|
|
|
|
def media_syncing_enabled(self) -> bool:
|
|
return self.profile["syncMedia"]
|
|
|
|
def auto_syncing_enabled(self) -> bool:
|
|
return self.profile["autoSync"]
|
|
|
|
def sync_auth(self) -> SyncAuth | None:
|
|
hkey = self.profile.get("syncKey")
|
|
if not hkey:
|
|
return None
|
|
return SyncAuth(hkey=hkey, host_number=self.profile.get("hostNum", 0))
|
|
|
|
def clear_sync_auth(self) -> None:
|
|
self.profile["syncKey"] = None
|
|
self.profile["syncUser"] = None
|
|
self.profile["hostNum"] = 0
|
|
|
|
def auto_sync_media_minutes(self) -> int:
|
|
return self.profile.get("autoSyncMediaMinutes", 15)
|
|
|
|
def set_auto_sync_media_minutes(self, val: int) -> None:
|
|
self.profile["autoSyncMediaMinutes"] = val
|
|
|
|
def show_browser_table_tooltips(self) -> bool:
|
|
return self.profile.get("browserTableTooltips", True)
|
|
|
|
def set_show_browser_table_tooltips(self, val: bool) -> None:
|
|
self.profile["browserTableTooltips"] = val
|