def __init__(
self,
db: DBProxy,
backend: RustBackend,
server: Optional["anki.storage.ServerData"] = None,
) -> None:
self.backend = backend
self._debugLog = not server
self.db = db
self.path = db._path
self._openLog()
self.log(self.path, anki.version)
self.server = server
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self, server is not None)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.conf = ConfigManager(self)
self.load()
if not self.crt:
d = datetime.datetime.today()
d -= datetime.timedelta(hours=4)
d = datetime.datetime(d.year, d.month, d.day)
d += datetime.timedelta(hours=4)
self.crt = int(time.mktime(d.timetuple()))
self._loadScheduler()
if not self.conf.get("newBury", False):
self.conf["newBury"] = True
self.setMod()
def __init__(self, db, server=False, log=False):
self._debugLog = log
self.db = db
self.path = db._path
self._openLog()
self.log(self.path, anki.version)
self.server = server
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self, server)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.load()
if not self.crt:
d = datetime.datetime.today()
d -= datetime.timedelta(hours=4)
d = datetime.datetime(d.year, d.month, d.day)
d += datetime.timedelta(hours=4)
self.crt = int(time.mktime(d.timetuple()))
self.sched = Scheduler(self)
if not self.conf.get("newBury", False):
mod = self.db.mod
self.sched.unburyCards()
self.db.mod = mod
def __init__(self, db, server=False, log=False):
self.devMode = os.getenv("ANKIDEV", "")
self._debugLog = log
self.db = db
self.path = db._path
self._openLog()
self.log(self.path, anki.version)
self.server = server
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self, server)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.load()
if not self.crt:
d = datetime.datetime.today()
d -= datetime.timedelta(hours=4)
d = datetime.datetime(d.year, d.month, d.day)
d += datetime.timedelta(hours=4)
self.crt = int(time.mktime(d.timetuple()))
if not server:
self.conf['localOffset'] = timezoneOffset()
self._loadScheduler()
if not self.conf.get("newBury", False):
self.conf['newBury'] = True
self.setMod()
def __init__(self, db, server=False, log=False):
self.ecdict = StarDict(os.path.join(get_current(), "test.db"))
self._debugLog = log
self.db = db
self.path = db._path
self._openLog()
self.log(self.path, anki.version)
self.server = server
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self, server)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.load()
if not self.crt:
d = datetime.datetime.today()
d -= datetime.timedelta(hours=4)
d = datetime.datetime(d.year, d.month, d.day)
d += datetime.timedelta(hours=4)
self.crt = int(time.mktime(d.timetuple()))
self._loadScheduler()
if not self.conf.get("newBury", False):
self.conf['newBury'] = True
self.setMod()
def __init__(self, db, server=False):
self.db = db
self.path = db._path
self.server = server
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.load()
if not self.crt:
d = datetime.datetime.today()
d -= datetime.timedelta(hours=4)
d = datetime.datetime(d.year, d.month, d.day)
d += datetime.timedelta(hours=4)
self.crt = int(time.mktime(d.timetuple()))
self.undoEnabled = False
self.sessionStartReps = 0
self.sessionStartTime = 0
self.lastSessionStart = 0
self._stdSched = Scheduler(self)
self.sched = self._stdSched
# check for improper shutdown
self.cleanup()
def __init__(self, db, server=False, log=False):
self._debugLog = log
self.db = db
self.path = db._path
# TODO: write tests for this
init_peewee_database(self.path)
run_migrations(self.path)
self._openLog()
self.log(self.path, anki.version)
self.server = server
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self, server)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.load()
if not self.crt:
d = datetime.datetime.today()
d -= datetime.timedelta(hours=4)
d = datetime.datetime(d.year, d.month, d.day)
d += datetime.timedelta(hours=4)
self.crt = int(time.mktime(d.timetuple()))
self._loadScheduler()
if not self.conf.get("newBury", False):
self.conf['newBury'] = True
self.setMod()
def create_note_type(self, noteTypeName, front, back, css):
# Create empty note type
mm = ModelManager(mw.col)
nt = mm.new(noteTypeName)
# Add fields into note type
mm.add_field(nt, mm.new_field("Word"))
mm.add_field(nt, mm.new_field("WordType"))
mm.add_field(nt, mm.new_field("Phonetic"))
mm.add_field(nt, mm.new_field("Example"))
mm.add_field(nt, mm.new_field("Sound"))
mm.add_field(nt, mm.new_field("Image"))
mm.add_field(nt, mm.new_field("Content"))
mm.add_field(nt, mm.new_field("Copyright"))
# Add template into note type
template = mm.new_template("AnkiFlash")
template["qfmt"] = front
template["afmt"] = back
nt["css"] = css
mm.add_template(nt, template)
# Save model / note type
mm.save(nt)
# Update UI
mw.reset()
def __init__(
self,
db: DBProxy,
backend: RustBackend,
server: bool = False,
log: bool = False,
) -> None:
self.backend = backend
self._debugLog = log
self.db = db
self.path = db._path
self._openLog()
self.log(self.path, anki.version)
self.server = server
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self, server)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.conf = ConfigManager(self)
self._loadScheduler()
def __init__(
self,
path: str,
backend: Optional[RustBackend] = None,
server: bool = False,
log: bool = False,
) -> None:
self._backend = backend or RustBackend(server=server)
self.db: Optional[DBProxy] = None
self._should_log = log
self.server = server
self.path = os.path.abspath(path)
self.reopen()
self.log(self.path, anki.version)
self._lastSave = time.time()
self.clearUndo()
self.media = MediaManager(self, server)
self.models = ModelManager(self)
self.decks = DeckManager(self)
self.tags = TagManager(self)
self.conf = ConfigManager(self)
self._loadScheduler()
def update_note_type(self, noteTypeName, front, back, css):
noteType = mw.col.models.byName(noteTypeName)
if noteType == None:
raise RuntimeError("{} Note type not found!".format(noteTypeName))
# Get template
tempates = noteType["tmpls"]
for temp in tempates:
if temp["name"] == "AnkiFlash":
template = temp
# Add template into note type
template["qfmt"] = front
template["afmt"] = back
noteType["css"] = css
# Save model / note type
mm = ModelManager(mw.col)
mm.save(noteType)
# Update UI
mw.reset()
def add(self, front, back, deck_name, model_name):
default_deck = self.collection.decks.allNames()[0]
default_model = self.collection.models.allNames()[0]
deck_name = unicode(deck_name or default_deck, sys.getfilesystemencoding())
model_name = unicode(model_name or default_model, sys.getfilesystemencoding())
model = self.collection.models.byName(model_name)
if not model:
mm = ModelManager(self.collection)
model = mm.new(model_name)
mm.save(model)
model['did'] = did = self.collection.decks.id(deck_name)
self.collection.models.save()
note = self.collection.newNote()
note['Front']= unicode(front or "", sys.getfilesystemencoding())
note['Back']= unicode(back or "", sys.getfilesystemencoding())
note.model()['did']= did
self.collection.addNote(note)
self.collection.save()
self.collection.genCards(self.collection.models.nids(model))
