mirror of
https://github.com/ankitects/anki.git
synced 2025-09-18 22:12:21 -04:00
facts->notes
This commit is contained in:
Damien Elmes
parent
be921563f0
commit
87da9f48b1
11 changed files with 194 additions and 195 deletions
|
|
@ -6,7 +6,6 @@ from aqt.qt import *
|
|||
import sys, re
|
||||
import aqt.forms
|
||||
import anki
|
||||
from anki.facts import Fact
|
||||
from anki.errors import *
|
||||
from anki.utils import stripHTML
|
||||
from aqt.utils import saveGeom, restoreGeom, showWarning, askUser, shortcut, \
|
||||
|
|
@ -37,7 +36,7 @@ class AddCards(QDialog):
|
|||
addHook('currentModelChanged', self.onReset)
|
||||
self.mw.requireReset(modal=True)
|
||||
self.open()
|
||||
self.setupNewFact()
|
||||
self.setupNewNote()
|
||||
|
||||
def setupEditor(self):
|
||||
self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea, True)
|
||||
|
|
@ -75,78 +74,78 @@ class AddCards(QDialog):
|
|||
b.setEnabled(False)
|
||||
self.historyButton = b
|
||||
|
||||
# FIXME: need to make sure to clean up fact on exit
|
||||
def setupNewFact(self, set=True):
|
||||
f = self.mw.deck.newFact()
|
||||
# FIXME: need to make sure to clean up note on exit
|
||||
def setupNewNote(self, set=True):
|
||||
f = self.mw.deck.newNote()
|
||||
f.tags = f.model()['tags']
|
||||
if set:
|
||||
self.editor.setFact(f)
|
||||
self.editor.setNote(f)
|
||||
return f
|
||||
|
||||
def onReset(self, model=None, keep=False):
|
||||
oldFact = self.editor.fact
|
||||
fact = self.setupNewFact(set=False)
|
||||
flds = fact.model()['flds']
|
||||
# copy fields from old fact
|
||||
if oldFact:
|
||||
oldNote = self.editor.note
|
||||
note = self.setupNewNote(set=False)
|
||||
flds = note.model()['flds']
|
||||
# copy fields from old note
|
||||
if oldNote:
|
||||
if not keep:
|
||||
self.removeTempFact(oldFact)
|
||||
for n in range(len(fact.fields)):
|
||||
self.removeTempNote(oldNote)
|
||||
for n in range(len(note.fields)):
|
||||
try:
|
||||
if not keep or flds[n]['sticky']:
|
||||
fact.fields[n] = oldFact.fields[n]
|
||||
note.fields[n] = oldNote.fields[n]
|
||||
else:
|
||||
fact.fields[n] = ""
|
||||
note.fields[n] = ""
|
||||
except IndexError:
|
||||
break
|
||||
self.editor.setFact(fact)
|
||||
self.editor.setNote(note)
|
||||
|
||||
def removeTempFact(self, fact):
|
||||
if not fact or not fact.id:
|
||||
def removeTempNote(self, note):
|
||||
if not note or not note.id:
|
||||
return
|
||||
# we don't have to worry about cards; just the fact
|
||||
self.mw.deck._remFacts([fact.id])
|
||||
# we don't have to worry about cards; just the note
|
||||
self.mw.deck._remNotes([note.id])
|
||||
|
||||
def addHistory(self, fact):
|
||||
txt = stripHTMLMedia(",".join(fact.fields))[:30]
|
||||
self.history.append((fact.id, txt))
|
||||
def addHistory(self, note):
|
||||
txt = stripHTMLMedia(",".join(note.fields))[:30]
|
||||
self.history.append((note.id, txt))
|
||||
self.history = self.history[-15:]
|
||||
self.historyButton.setEnabled(True)
|
||||
|
||||
def onHistory(self):
|
||||
m = QMenu(self)
|
||||
for fid, txt in self.history:
|
||||
for nid, txt in self.history:
|
||||
a = m.addAction(_("Edit %s" % txt))
|
||||
a.connect(a, SIGNAL("triggered()"),
|
||||
lambda fid=fid: self.editHistory(fid))
|
||||
lambda nid=nid: self.editHistory(nid))
|
||||
m.exec_(self.historyButton.mapToGlobal(QPoint(0,0)))
|
||||
|
||||
def editHistory(self, fid):
|
||||
def editHistory(self, nid):
|
||||
browser = aqt.dialogs.open("Browser", self.mw)
|
||||
browser.form.searchEdit.setText("fid:%d" % fid)
|
||||
browser.form.searchEdit.setText("nid:%d" % nid)
|
||||
browser.onSearch()
|
||||
|
||||
def addFact(self, fact):
|
||||
if any(fact.problems()):
|
||||
def addNote(self, note):
|
||||
if any(note.problems()):
|
||||
showWarning(_(
|
||||
"Some fields are missing or not unique."),
|
||||
help="AddItems#AddError")
|
||||
return
|
||||
cards = self.mw.deck.addFact(fact)
|
||||
cards = self.mw.deck.addNote(note)
|
||||
if not cards:
|
||||
showWarning(_("""\
|
||||
The input you have provided would make an empty
|
||||
question or answer on all cards."""), help="AddItems")
|
||||
return
|
||||
self.addHistory(fact)
|
||||
self.addHistory(note)
|
||||
# FIXME: return to overview on add?
|
||||
return fact
|
||||
return note
|
||||
|
||||
def addCards(self):
|
||||
self.editor.saveNow()
|
||||
fact = self.editor.fact
|
||||
fact = self.addFact(fact)
|
||||
if not fact:
|
||||
note = self.editor.note
|
||||
note = self.addNote(note)
|
||||
if not note:
|
||||
return
|
||||
tooltip("Added", period=500)
|
||||
# stop anything playing
|
||||
|
|
@ -168,8 +167,8 @@ question or answer on all cards."""), help="AddItems")
|
|||
removeHook('reset', self.onReset)
|
||||
removeHook('currentModelChanged', self.onReset)
|
||||
clearAudioQueue()
|
||||
self.removeTempFact(self.editor.fact)
|
||||
self.editor.setFact(None)
|
||||
self.removeTempNote(self.editor.note)
|
||||
self.editor.setNote(None)
|
||||
self.modelChooser.cleanup()
|
||||
self.mw.maybeReset()
|
||||
saveGeom(self, "add")
|
||||
|
|
|
|||
144
aqt/browser.py
144
aqt/browser.py
|
|
@ -36,7 +36,7 @@ class DeckModel(QAbstractTableModel):
|
|||
self.deck = browser.deck
|
||||
self.sortKey = None
|
||||
self.activeCols = self.deck.conf.get(
|
||||
"activeCols", ["factFld", "template", "cardDue", "cardEase"])
|
||||
"activeCols", ["noteFld", "template", "cardDue", "cardEase"])
|
||||
self.cards = []
|
||||
self.cardObjs = {}
|
||||
|
||||
|
|
@ -46,9 +46,9 @@ class DeckModel(QAbstractTableModel):
|
|||
self.cardObjs[id] = self.deck.getCard(id)
|
||||
return self.cardObjs[id]
|
||||
|
||||
def refreshFact(self, fact):
|
||||
def refreshNote(self, note):
|
||||
refresh = False
|
||||
for c in fact.cards():
|
||||
for c in note.cards():
|
||||
if c.id in self.cardObjs:
|
||||
del self.cardObjs[c.id]
|
||||
refresh = True
|
||||
|
|
@ -123,7 +123,7 @@ class DeckModel(QAbstractTableModel):
|
|||
|
||||
def beginReset(self):
|
||||
self.browser.editor.saveNow()
|
||||
self.browser.editor.setFact(None, hide=False)
|
||||
self.browser.editor.setNote(None, hide=False)
|
||||
self.browser.mw.progress.start()
|
||||
self.saveSelection()
|
||||
self.beginResetModel()
|
||||
|
|
@ -192,7 +192,7 @@ class DeckModel(QAbstractTableModel):
|
|||
except:
|
||||
# debugging
|
||||
print column, self.activeCols
|
||||
return "factFld"
|
||||
return "noteFld"
|
||||
return type
|
||||
|
||||
def columnData(self, index):
|
||||
|
|
@ -204,17 +204,17 @@ class DeckModel(QAbstractTableModel):
|
|||
return self.question()
|
||||
elif type == "answer":
|
||||
return self.answer()
|
||||
elif type == "factFld":
|
||||
f = c.fact()
|
||||
elif type == "noteFld":
|
||||
f = c.note()
|
||||
return self.formatQA(f.fields[self.deck.models.sortIdx(f.model())])
|
||||
elif type == "template":
|
||||
return c.template()['name']
|
||||
elif type == "cardDue":
|
||||
return self.nextDue(c, index)
|
||||
elif type == "factCrt":
|
||||
return time.strftime("%Y-%m-%d", time.localtime(c.fact().id/1000))
|
||||
elif type == "factMod":
|
||||
return time.strftime("%Y-%m-%d", time.localtime(c.fact().mod))
|
||||
elif type == "noteCrt":
|
||||
return time.strftime("%Y-%m-%d", time.localtime(c.note().id/1000))
|
||||
elif type == "noteMod":
|
||||
return time.strftime("%Y-%m-%d", time.localtime(c.note().mod))
|
||||
elif type == "cardMod":
|
||||
return time.strftime("%Y-%m-%d", time.localtime(c.mod))
|
||||
elif type == "cardReps":
|
||||
|
|
@ -231,8 +231,8 @@ class DeckModel(QAbstractTableModel):
|
|||
return "%d%%" % (c.factor/10)
|
||||
elif type == "cardGroup":
|
||||
return self.browser.mw.deck.groups.name(c.gid)
|
||||
elif type == "factGroup":
|
||||
return self.browser.mw.deck.groups.name(c.fact().gid)
|
||||
elif type == "noteGroup":
|
||||
return self.browser.mw.deck.groups.name(c.note().gid)
|
||||
|
||||
def question(self):
|
||||
return self.formatQA(c.a())
|
||||
|
|
@ -280,7 +280,7 @@ class StatusDelegate(QItemDelegate):
|
|||
painter.save()
|
||||
painter.fillRect(option.rect, brush)
|
||||
painter.restore()
|
||||
elif c.fact().hasTag("Marked"):
|
||||
elif c.note().hasTag("Marked"):
|
||||
if index.row() % 2 == 0:
|
||||
brush = QBrush(QColor(COLOUR_MARKED1))
|
||||
else:
|
||||
|
|
@ -355,14 +355,14 @@ class Browser(QMainWindow):
|
|||
c(f.actionOptions, s, self.onOptions)
|
||||
c(f.actionUndo, s, self.mw.onUndo)
|
||||
c(f.actionInvertSelection, s, self.invertSelection)
|
||||
c(f.actionSelectFacts, s, self.selectFacts)
|
||||
c(f.actionSelectNotes, s, self.selectNotes)
|
||||
c(f.actionFindReplace, s, self.onFindReplace)
|
||||
c(f.actionFindDuplicates, s, self.onFindDupes)
|
||||
# jumps
|
||||
c(f.actionPreviousCard, s, self.onPreviousCard)
|
||||
c(f.actionNextCard, s, self.onNextCard)
|
||||
c(f.actionFind, s, self.onFind)
|
||||
c(f.actionFact, s, self.onFact)
|
||||
c(f.actionNote, s, self.onNote)
|
||||
c(f.actionTags, s, self.onTags)
|
||||
c(f.actionSort, s, self.onSort)
|
||||
c(f.actionCardList, s, self.onCardList)
|
||||
|
|
@ -381,7 +381,7 @@ class Browser(QMainWindow):
|
|||
saveSplitter(self.form.splitter_2, "editor2")
|
||||
saveSplitter(self.form.splitter_3, "editor3")
|
||||
self.editor.saveNow()
|
||||
self.editor.setFact(None)
|
||||
self.editor.setNote(None)
|
||||
saveGeom(self, "editor")
|
||||
saveState(self, "editor")
|
||||
saveHeader(self.form.tableView.horizontalHeader(), "editor")
|
||||
|
|
@ -407,10 +407,10 @@ class Browser(QMainWindow):
|
|||
('answer', _("Answer")),
|
||||
('template', _("Card")),
|
||||
('cardGroup', _("C.Group")),
|
||||
('factGroup', _("I.Group")),
|
||||
('factFld', _("Sort Field")),
|
||||
('factCrt', _("Created")),
|
||||
('factMod', _("Edited")),
|
||||
('noteGroup', _("I.Group")),
|
||||
('noteFld', _("Sort Field")),
|
||||
('noteCrt', _("Created")),
|
||||
('noteMod', _("Edited")),
|
||||
('cardMod', _("Reviewed")),
|
||||
('cardDue', _("Due")),
|
||||
('cardIvl', _("Interval")),
|
||||
|
|
@ -439,7 +439,7 @@ class Browser(QMainWindow):
|
|||
self.form.searchEdit.setCompleter(self.searchComp)
|
||||
|
||||
def onSearch(self, reset=True):
|
||||
"Careful: if reset is true, the current fact is saved."
|
||||
"Careful: if reset is true, the current note is saved."
|
||||
txt = unicode(self.form.searchEdit.text()).strip()
|
||||
sh = self.mw.config['searchHistory']
|
||||
if txt not in sh:
|
||||
|
|
@ -471,7 +471,7 @@ class Browser(QMainWindow):
|
|||
return selected
|
||||
|
||||
def onReset(self):
|
||||
self.editor.setFact(None)
|
||||
self.editor.setNote(None)
|
||||
self.onSearch()
|
||||
|
||||
# Table view & editor
|
||||
|
|
@ -494,21 +494,21 @@ class Browser(QMainWindow):
|
|||
self.editor.stealFocus = False
|
||||
|
||||
def onRowChanged(self, current, previous):
|
||||
"Update current fact and hide/show editor."
|
||||
"Update current note and hide/show editor."
|
||||
show = self.model.cards and self.updateTitle() == 1
|
||||
self.form.splitter_2.widget(1).setShown(not not show)
|
||||
if not show:
|
||||
self.editor.setFact(None)
|
||||
self.editor.setNote(None)
|
||||
else:
|
||||
self.card = self.model.getCard(
|
||||
self.form.tableView.selectionModel().currentIndex())
|
||||
self.editor.setFact(self.card.fact())
|
||||
self.editor.setNote(self.card.note())
|
||||
self.editor.card = self.card
|
||||
self.showCardInfo(self.card)
|
||||
self.updateToggles()
|
||||
|
||||
def refreshCurrentCard(self, fact):
|
||||
self.model.refreshFact(fact)
|
||||
def refreshCurrentCard(self, note):
|
||||
self.model.refreshNote(note)
|
||||
|
||||
# Headers & sorting
|
||||
######################################################################
|
||||
|
|
@ -533,7 +533,7 @@ class Browser(QMainWindow):
|
|||
|
||||
def onSortChanged(self, idx, ord):
|
||||
type = self.model.activeCols[idx]
|
||||
noSort = ("question", "answer", "template", "cardGroup", "factGroup")
|
||||
noSort = ("question", "answer", "template", "cardGroup", "noteGroup")
|
||||
if type in noSort:
|
||||
showInfo(_("Sorting on this column is not supported. Please "
|
||||
"choose another."))
|
||||
|
|
@ -541,7 +541,7 @@ class Browser(QMainWindow):
|
|||
if self.deck.conf['sortType'] != type:
|
||||
self.deck.conf['sortType'] = type
|
||||
# default to descending for non-text fields
|
||||
if type == "factFld":
|
||||
if type == "noteFld":
|
||||
ord = not ord
|
||||
self.deck.conf['sortBackwards'] = ord
|
||||
self.onSearch()
|
||||
|
|
@ -592,7 +592,7 @@ class Browser(QMainWindow):
|
|||
def setColumnSizes(self):
|
||||
hh = self.form.tableView.horizontalHeader()
|
||||
for c, i in enumerate(self.model.activeCols):
|
||||
if i in ("question", "answer", "factFld"):
|
||||
if i in ("question", "answer", "noteFld"):
|
||||
hh.setResizeMode(c, QHeaderView.Stretch)
|
||||
else:
|
||||
hh.setResizeMode(c, QHeaderView.Interactive)
|
||||
|
|
@ -809,24 +809,24 @@ class Browser(QMainWindow):
|
|||
return [self.model.cards[idx.row()] for idx in
|
||||
self.form.tableView.selectionModel().selectedRows()]
|
||||
|
||||
def selectedFacts(self):
|
||||
def selectedNotes(self):
|
||||
return self.deck.db.list("""
|
||||
select distinct fid from cards
|
||||
select distinct nid from cards
|
||||
where id in %s""" % ids2str(
|
||||
[self.model.cards[idx.row()] for idx in
|
||||
self.form.tableView.selectionModel().selectedRows()]))
|
||||
|
||||
def selectedFactsAsCards(self):
|
||||
def selectedNotesAsCards(self):
|
||||
return self.deck.db.list(
|
||||
"select id from cards where fid in (%s)" %
|
||||
",".join([str(s) for s in self.selectedFacts()]))
|
||||
"select id from cards where nid in (%s)" %
|
||||
",".join([str(s) for s in self.selectedNotes()]))
|
||||
|
||||
def oneModelFacts(self):
|
||||
sf = self.selectedFacts()
|
||||
def oneModelNotes(self):
|
||||
sf = self.selectedNotes()
|
||||
if not sf:
|
||||
return
|
||||
mods = self.deck.db.scalar("""
|
||||
select count(distinct mid) from facts
|
||||
select count(distinct mid) from notes
|
||||
where id in %s""" % ids2str(sf))
|
||||
if mods > 1:
|
||||
showInfo(_("Please select cards from only one model."))
|
||||
|
|
@ -840,14 +840,14 @@ where id in %s""" % ids2str(sf))
|
|||
######################################################################
|
||||
|
||||
def genCards(self):
|
||||
fids = self.oneModelFacts()
|
||||
if fids:
|
||||
GenCards(self, fids)
|
||||
nids = self.oneModelNotes()
|
||||
if nids:
|
||||
GenCards(self, nids)
|
||||
|
||||
def onChangeModel(self):
|
||||
fids = self.oneModelFacts()
|
||||
if fids:
|
||||
ChangeModel(self, fids)
|
||||
nids = self.oneModelNotes()
|
||||
if nids:
|
||||
ChangeModel(self, nids)
|
||||
|
||||
def cram(self):
|
||||
return showInfo("not yet implemented")
|
||||
|
|
@ -900,11 +900,11 @@ where id in %s""" % ids2str(sf))
|
|||
self.selectedCards()), mod, gid)
|
||||
if frm.setInitial.isChecked():
|
||||
self.deck.db.execute(
|
||||
"update facts set mod=?, gid=? where id in " + ids2str(
|
||||
self.selectedFacts()), mod, gid)
|
||||
"update notes set mod=?, gid=? where id in " + ids2str(
|
||||
self.selectedNotes()), mod, gid)
|
||||
else:
|
||||
self.deck.db.execute("""
|
||||
update cards set mod=?, gid=(select gid from facts where id = cards.fid)
|
||||
update cards set mod=?, gid=(select gid from notes where id = cards.nid)
|
||||
where id in %s""" % ids2str(self.selectedCards()), mod)
|
||||
self.onSearch(reset=False)
|
||||
self.mw.requireReset()
|
||||
|
|
@ -929,7 +929,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
|
|||
label = _("Add Tags")
|
||||
if label:
|
||||
self.mw.checkpoint(label)
|
||||
func(self.selectedFacts(), tags)
|
||||
func(self.selectedNotes(), tags)
|
||||
self.onSearch(reset=False)
|
||||
self.mw.requireReset()
|
||||
self.model.endReset()
|
||||
|
|
@ -962,7 +962,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
|
|||
self.mw.requireReset()
|
||||
|
||||
def isMarked(self):
|
||||
return not not (self.card and self.card.fact().hasTag("Marked"))
|
||||
return not not (self.card and self.card.note().hasTag("Marked"))
|
||||
|
||||
def onMark(self, mark):
|
||||
if mark:
|
||||
|
|
@ -1023,9 +1023,9 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
|
|||
# Edit: selection
|
||||
######################################################################
|
||||
|
||||
def selectFacts(self):
|
||||
fids = self.selectedFacts()
|
||||
self.form.searchEdit.setText("fid:"+",".join([str(x) for x in fids]))
|
||||
def selectNotes(self):
|
||||
nids = self.selectedNotes()
|
||||
self.form.searchEdit.setText("nid:"+",".join([str(x) for x in nids]))
|
||||
# clear the selection so we don't waste energy preserving it
|
||||
tv = self.form.tableView
|
||||
tv.selectionModel().clear()
|
||||
|
|
@ -1084,7 +1084,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
|
|||
######################################################################
|
||||
|
||||
def onFindReplace(self):
|
||||
sf = self.selectedFacts()
|
||||
sf = self.selectedNotes()
|
||||
if not sf:
|
||||
return
|
||||
import anki.find
|
||||
|
|
@ -1123,8 +1123,8 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
|
|||
self.model.endReset()
|
||||
self.mw.progress.finish()
|
||||
showInfo(ngettext(
|
||||
"%(a)d of %(b)d fact updated",
|
||||
"%(a)d of %(b)d facts updated", len(sf)) % {
|
||||
"%(a)d of %(b)d note updated",
|
||||
"%(a)d of %(b)d notes updated", len(sf)) % {
|
||||
'a': changed,
|
||||
'b': len(sf),
|
||||
})
|
||||
|
|
@ -1141,7 +1141,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
|
|||
aqt = ankiqt.forms.finddupes.Ui_Dialog()
|
||||
dialog.setupUi(win)
|
||||
restoreGeom(win, "findDupes")
|
||||
fields = sorted(self.card.fact.model.fieldModels, key=attrgetter("name"))
|
||||
fields = sorted(self.card.note.model.fieldModels, key=attrgetter("name"))
|
||||
# per-model data
|
||||
data = self.deck.db.all("""
|
||||
select fm.id, m.name || '>' || fm.name from fieldmodels fm, models m
|
||||
|
|
@ -1196,7 +1196,7 @@ select fm.id, fm.name from fieldmodels fm""")
|
|||
|
||||
for group in res:
|
||||
t += '<li><a href="%s">%s</a>' % (
|
||||
"fid:" + ",".join(str(id) for id in group[1]),
|
||||
"nid:" + ",".join(str(id) for id in group[1]),
|
||||
group[0])
|
||||
|
||||
t += "</ol>"
|
||||
|
|
@ -1207,7 +1207,7 @@ select fm.id, fm.name from fieldmodels fm""")
|
|||
def dupeLinkClicked(self, link):
|
||||
self.form.searchEdit.setText(link.toString())
|
||||
self.onSearch()
|
||||
self.onFact()
|
||||
self.onNote()
|
||||
|
||||
# Jumping
|
||||
######################################################################
|
||||
|
|
@ -1231,7 +1231,7 @@ select fm.id, fm.name from fieldmodels fm""")
|
|||
self.form.searchEdit.setFocus()
|
||||
self.form.searchEdit.selectAll()
|
||||
|
||||
def onFact(self):
|
||||
def onNote(self):
|
||||
self.editor.focus()
|
||||
|
||||
def onTags(self):
|
||||
|
|
@ -1248,10 +1248,10 @@ select fm.id, fm.name from fieldmodels fm""")
|
|||
|
||||
class GenCards(QDialog):
|
||||
|
||||
def __init__(self, browser, fids):
|
||||
def __init__(self, browser, nids):
|
||||
QDialog.__init__(self, browser)
|
||||
self.browser = browser
|
||||
self.fids = fids
|
||||
self.nids = nids
|
||||
self.form = aqt.forms.gencards.Ui_Dialog()
|
||||
self.form.setupUi(self)
|
||||
self.setWindowModality(Qt.WindowModal)
|
||||
|
|
@ -1262,7 +1262,7 @@ class GenCards(QDialog):
|
|||
|
||||
def getSelection(self):
|
||||
# get cards to enable
|
||||
f = self.browser.deck.getFact(self.fids[0])
|
||||
f = self.browser.deck.getNote(self.nids[0])
|
||||
self.model = f.model()
|
||||
self.items = []
|
||||
for t in self.model.templates:
|
||||
|
|
@ -1296,15 +1296,15 @@ class GenCards(QDialog):
|
|||
mw = self.browser.mw
|
||||
mw.checkpoint(_("Generate Cards"))
|
||||
mw.progress.start()
|
||||
for c, fid in enumerate(self.fids):
|
||||
f = mw.deck.getFact(fid)
|
||||
for c, nid in enumerate(self.nids):
|
||||
f = mw.deck.getNote(nid)
|
||||
mw.deck.genCards(f, tplates)
|
||||
if c % 100 == 0:
|
||||
mw.progress.update()
|
||||
if unused:
|
||||
cids = mw.deck.db.list("""
|
||||
select id from cards where fid in %s and ord in %s""" % (
|
||||
ids2str(self.fids), ids2str(unused)))
|
||||
select id from cards where nid in %s and ord in %s""" % (
|
||||
ids2str(self.nids), ids2str(unused)))
|
||||
mw.deck.remCards(cids)
|
||||
mw.progress.finish()
|
||||
mw.requireReset()
|
||||
|
|
@ -1318,11 +1318,11 @@ select id from cards where fid in %s and ord in %s""" % (
|
|||
|
||||
class ChangeModel(QDialog):
|
||||
|
||||
def __init__(self, browser, fids):
|
||||
def __init__(self, browser, nids):
|
||||
QDialog.__init__(self, browser)
|
||||
self.browser = browser
|
||||
self.fids = fids
|
||||
self.oldModel = browser.card.fact().model()
|
||||
self.nids = nids
|
||||
self.oldModel = browser.card.note().model()
|
||||
self.form = aqt.forms.changemodel.Ui_Dialog()
|
||||
self.form.setupUi(self)
|
||||
self.setWindowModality(Qt.WindowModal)
|
||||
|
|
@ -1461,14 +1461,14 @@ class ChangeModel(QDialog):
|
|||
if any(True for c in cmap.values() if c is None):
|
||||
if not askUser(_("""\
|
||||
Any cards with templates mapped to nothing will be deleted. \
|
||||
If a fact has no remaining cards, it will be lost. \
|
||||
If a note has no remaining cards, it will be lost. \
|
||||
Are you sure you want to continue?""")):
|
||||
return
|
||||
self.browser.mw.checkpoint(_("Change Model"))
|
||||
b = self.browser
|
||||
b.mw.progress.start()
|
||||
b.model.beginReset()
|
||||
self.oldModel.changeModel(self.fids, self.targetModel, fmap, cmap)
|
||||
self.oldModel.changeModel(self.nids, self.targetModel, fmap, cmap)
|
||||
b.onSearch(reset=False)
|
||||
b.model.endReset()
|
||||
b.mw.progress.finish()
|
||||
|
|
|
|||
|
|
@ -20,17 +20,17 @@ class ResizingTextEdit(QTextEdit):
|
|||
class CardLayout(QDialog):
|
||||
|
||||
# type is previewCards() type
|
||||
def __init__(self, mw, fact, type=0, ord=0, parent=None):
|
||||
def __init__(self, mw, note, type=0, ord=0, parent=None):
|
||||
QDialog.__init__(self, parent or mw, Qt.Window)
|
||||
raise Exception("Remember to disallow media&latex refs in edit.")
|
||||
self.mw = aqt.mw
|
||||
self.parent = parent or mw
|
||||
self.fact = fact
|
||||
self.note = note
|
||||
self.type = type
|
||||
self.ord = ord
|
||||
self.deck = self.mw.deck
|
||||
self.mm = self.mw.deck.models
|
||||
self.model = fact.model()
|
||||
self.model = note.model()
|
||||
self.form = aqt.forms.clayout.Ui_Dialog()
|
||||
self.form.setupUi(self)
|
||||
self.setWindowTitle(_("%s Layout") % self.model['name'])
|
||||
|
|
@ -50,13 +50,13 @@ class CardLayout(QDialog):
|
|||
self.exec_()
|
||||
|
||||
def reload(self, first=False):
|
||||
self.cards = self.deck.previewCards(self.fact, self.type)
|
||||
self.cards = self.deck.previewCards(self.note, self.type)
|
||||
if not self.cards:
|
||||
self.accept()
|
||||
if first:
|
||||
showInfo(_("Please enter some text first."))
|
||||
else:
|
||||
showInfo(_("The current fact was deleted."))
|
||||
showInfo(_("The current note was deleted."))
|
||||
return
|
||||
self.fillCardList()
|
||||
self.fillFieldList()
|
||||
|
|
@ -76,7 +76,7 @@ class CardLayout(QDialog):
|
|||
_("Templates that will be created:"))
|
||||
elif self.type == 1:
|
||||
f.templateType.setText(
|
||||
_("Templates used by fact:"))
|
||||
_("Templates used by note:"))
|
||||
else:
|
||||
f.templateType.setText(
|
||||
_("All templates:"))
|
||||
|
|
@ -259,10 +259,10 @@ class CardLayout(QDialog):
|
|||
if self.needFieldRebuild:
|
||||
modified = True
|
||||
if modified:
|
||||
self.fact.model.setModified()
|
||||
self.note.model.setModified()
|
||||
self.deck.flushMod()
|
||||
if self.factedit and self.factedit.onChange:
|
||||
self.factedit.onChange("all")
|
||||
if self.noteedit and self.noteedit.onChange:
|
||||
self.noteedit.onChange("all")
|
||||
reset=False
|
||||
if reset:
|
||||
self.mw.reset()
|
||||
|
|
@ -358,7 +358,7 @@ class CardLayout(QDialog):
|
|||
if fld['name'] != name:
|
||||
self.mm.renameField(self.model, fld, name)
|
||||
# as the field name has changed, we have to regenerate cards
|
||||
self.cards = self.deck.previewCards(self.fact, self.type)
|
||||
self.cards = self.deck.previewCards(self.note, self.type)
|
||||
self.cardChanged(0)
|
||||
self.renderPreview()
|
||||
self.fillFieldList()
|
||||
|
|
@ -413,7 +413,7 @@ class CardLayout(QDialog):
|
|||
if len(self.model.fields) < 2:
|
||||
showInfo(_("Please add a new field first."))
|
||||
return
|
||||
if askUser(_("Delete this field and its data from all facts?")):
|
||||
if askUser(_("Delete this field and its data from all notes?")):
|
||||
self.mw.progress.start()
|
||||
self.model.delField(self.field)
|
||||
self.mw.progress.finish()
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ class EditCurrent(QDialog):
|
|||
SIGNAL("rejected()"),
|
||||
self.onSave)
|
||||
self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea)
|
||||
self.editor.setFact(self.mw.reviewer.card.fact())
|
||||
self.editor.setNote(self.mw.reviewer.card.note())
|
||||
restoreGeom(self, "editcurrent")
|
||||
addHook("closeEditCurrent", self.onSave)
|
||||
self.mw.requireReset(modal=True)
|
||||
|
|
@ -35,7 +35,7 @@ class EditCurrent(QDialog):
|
|||
def onSave(self):
|
||||
removeHook("closeEditCurrent", self.onSave)
|
||||
self.editor.saveNow()
|
||||
self.editor.setFact(None)
|
||||
self.editor.setNote(None)
|
||||
r = self.mw.reviewer
|
||||
r.card.load()
|
||||
r.keep = True
|
||||
|
|
|
|||
|
|
@ -188,12 +188,12 @@ $(function () {
|
|||
</body></html>
|
||||
"""
|
||||
|
||||
# caller is responsible for resetting fact on reset
|
||||
# caller is responsible for resetting note on reset
|
||||
class Editor(object):
|
||||
def __init__(self, mw, widget, addMode=False):
|
||||
self.widget = widget
|
||||
self.mw = mw
|
||||
self.fact = None
|
||||
self.note = None
|
||||
self.stealFocus = True
|
||||
self.addMode = addMode
|
||||
self._loaded = False
|
||||
|
|
@ -311,28 +311,28 @@ class Editor(object):
|
|||
type = 1; ord = self.card.ord
|
||||
else:
|
||||
type = 0; ord = 0
|
||||
CardLayout(self.mw, self.fact, type=type, ord=ord, parent=self.widget)
|
||||
self.loadFact()
|
||||
CardLayout(self.mw, self.note, type=type, ord=ord, parent=self.widget)
|
||||
self.loadNote()
|
||||
|
||||
# JS->Python bridge
|
||||
######################################################################
|
||||
|
||||
def bridge(self, str):
|
||||
if not self.fact or not runHook:
|
||||
if not self.note or not runHook:
|
||||
# shutdown
|
||||
return
|
||||
# focus lost or key/button pressed?
|
||||
if str.startswith("blur") or str.startswith("key"):
|
||||
(type, txt) = str.split(":", 1)
|
||||
self.fact.fields[self.currentField] = self.mungeHTML(txt)
|
||||
self.note.fields[self.currentField] = self.mungeHTML(txt)
|
||||
self.mw.requireReset()
|
||||
self.fact.flush()
|
||||
self.note.flush()
|
||||
if type == "blur":
|
||||
if not self._keepButtons:
|
||||
self.disableButtons()
|
||||
runHook("editFocusLost", self.fact)
|
||||
runHook("editFocusLost", self.note)
|
||||
else:
|
||||
runHook("editTimer", self.fact)
|
||||
runHook("editTimer", self.note)
|
||||
self.checkValid()
|
||||
# focused into field?
|
||||
elif str.startswith("focus"):
|
||||
|
|
@ -358,19 +358,19 @@ class Editor(object):
|
|||
txt = ""
|
||||
return txt
|
||||
|
||||
# Setting/unsetting the current fact
|
||||
# Setting/unsetting the current note
|
||||
######################################################################
|
||||
|
||||
def _loadFinished(self, w):
|
||||
self._loaded = True
|
||||
if self.fact:
|
||||
self.loadFact()
|
||||
if self.note:
|
||||
self.loadNote()
|
||||
|
||||
def setFact(self, fact, hide=True):
|
||||
"Make FACT the current fact."
|
||||
self.fact = fact
|
||||
def setNote(self, note, hide=True):
|
||||
"Make NOTE the current note."
|
||||
self.note = note
|
||||
# change timer
|
||||
if self.fact:
|
||||
if self.note:
|
||||
self.web.setHtml(_html % (getBase(self.mw.deck), anki.js.all,
|
||||
_("Show Duplicates")),
|
||||
loadCB=self._loadFinished)
|
||||
|
|
@ -379,12 +379,12 @@ class Editor(object):
|
|||
elif hide:
|
||||
self.widget.hide()
|
||||
|
||||
def loadFact(self, field=0):
|
||||
def loadNote(self, field=0):
|
||||
if not self._loaded:
|
||||
# will be loaded when page is ready
|
||||
return
|
||||
self.web.eval("setFields(%s, %d);" % (
|
||||
simplejson.dumps(self.fact.items()), field))
|
||||
simplejson.dumps(self.note.items()), field))
|
||||
self.web.eval("setFonts(%s);" % (
|
||||
simplejson.dumps(self.fonts())))
|
||||
self.checkValid()
|
||||
|
|
@ -397,11 +397,11 @@ class Editor(object):
|
|||
|
||||
def fonts(self):
|
||||
return [(f['font'], f['esize'])
|
||||
for f in self.fact.model()['flds']]
|
||||
for f in self.note.model()['flds']]
|
||||
|
||||
def saveNow(self):
|
||||
"Must call this before adding cards, closing dialog, etc."
|
||||
if not self.fact:
|
||||
if not self.note:
|
||||
return
|
||||
self._keepButtons = True
|
||||
self.web.eval("saveField('blur');")
|
||||
|
|
@ -411,7 +411,7 @@ class Editor(object):
|
|||
def checkValid(self):
|
||||
cols = []
|
||||
self.dupe = None
|
||||
for c, p in enumerate(self.fact.problems()):
|
||||
for c, p in enumerate(self.note.problems()):
|
||||
if not p:
|
||||
cols.append("#fff")
|
||||
elif p == "unique":
|
||||
|
|
@ -426,16 +426,16 @@ class Editor(object):
|
|||
self.web.eval("hideDupes();")
|
||||
|
||||
def showDupes(self):
|
||||
contents = self.fact.fields[self.dupe]
|
||||
contents = self.note.fields[self.dupe]
|
||||
browser = aqt.dialogs.open("Browser", self.mw)
|
||||
browser.form.searchEdit.setText(
|
||||
"'model:%s' '%s'" % (self.fact.model().name, contents))
|
||||
"'model:%s' '%s'" % (self.note.model().name, contents))
|
||||
browser.onSearch()
|
||||
|
||||
def fieldsAreBlank(self):
|
||||
if not self.fact:
|
||||
if not self.note:
|
||||
return True
|
||||
for f in self.fact.fields:
|
||||
for f in self.note.fields:
|
||||
if f:
|
||||
return False
|
||||
return True
|
||||
|
|
@ -450,12 +450,12 @@ class Editor(object):
|
|||
form.setupUi(d)
|
||||
d.connect(form.buttonBox, SIGNAL("helpRequested()"),
|
||||
lambda: aqt.openHelp("HtmlEditor"))
|
||||
form.textEdit.setPlainText(self.fact.fields[self.currentField])
|
||||
form.textEdit.setPlainText(self.note.fields[self.currentField])
|
||||
form.textEdit.moveCursor(QTextCursor.End)
|
||||
d.exec_()
|
||||
self.fact.fields[self.currentField] = unicode(
|
||||
self.note.fields[self.currentField] = unicode(
|
||||
form.textEdit.toPlainText())
|
||||
self.loadFact(self.currentField)
|
||||
self.loadNote(self.currentField)
|
||||
|
||||
# Tag and group handling
|
||||
######################################################################
|
||||
|
|
@ -494,32 +494,32 @@ class Editor(object):
|
|||
self.tags.setDeck(self.mw.deck)
|
||||
if self.addMode:
|
||||
self.group.setDeck(self.mw.deck)
|
||||
self.tags.setText(self.fact.stringTags().strip())
|
||||
if getattr(self.fact, 'gid', None):
|
||||
gid = self.fact.gid
|
||||
self.tags.setText(self.note.stringTags().strip())
|
||||
if getattr(self.note, 'gid', None):
|
||||
gid = self.note.gid
|
||||
else:
|
||||
gid = self.fact.model().conf['gid']
|
||||
gid = self.note.model().conf['gid']
|
||||
self.group.setText(self.mw.deck.groups.name(gid))
|
||||
|
||||
def saveTagsAndGroup(self):
|
||||
if not self.fact:
|
||||
if not self.note:
|
||||
return
|
||||
self.fact.tags = self.mw.deck.tags.split(unicode(self.tags.text()))
|
||||
self.note.tags = self.mw.deck.tags.split(unicode(self.tags.text()))
|
||||
if self.addMode:
|
||||
# save group and tags to model
|
||||
self.fact.gid = self.mw.deck.groups.id(unicode(self.group.text()))
|
||||
m = self.fact.model()
|
||||
m['gid'] = self.fact.gid
|
||||
m['tags'] = self.fact.tags
|
||||
self.note.gid = self.mw.deck.groups.id(unicode(self.group.text()))
|
||||
m = self.note.model()
|
||||
m['gid'] = self.note.gid
|
||||
m['tags'] = self.note.tags
|
||||
self.mw.deck.models.save(m)
|
||||
self.fact.flush()
|
||||
runHook("tagsAndGroupUpdated", self.fact)
|
||||
self.note.flush()
|
||||
runHook("tagsAndGroupUpdated", self.note)
|
||||
|
||||
def changeGroup(self):
|
||||
id = self.fact.id
|
||||
id = self.note.id
|
||||
runHook("closeEditCurrent")
|
||||
browser = aqt.dialogs.open("Browser", self.mw)
|
||||
browser.form.searchEdit.setText("fid:%d" % id)
|
||||
browser.form.searchEdit.setText("nid:%d" % id)
|
||||
browser.onSearch()
|
||||
browser.setGroup(True)
|
||||
|
||||
|
|
@ -547,7 +547,7 @@ class Editor(object):
|
|||
def onCloze(self):
|
||||
# check that the model is set up for cloze deletion
|
||||
ok = False
|
||||
for t in self.fact.model().templates:
|
||||
for t in self.note.model().templates:
|
||||
if "cloze" in t['qfmt'] or "cloze" in t['afmt']:
|
||||
ok = True
|
||||
break
|
||||
|
|
@ -555,7 +555,7 @@ class Editor(object):
|
|||
showInfo(_("Please use a cloze deletion model."),
|
||||
help="ClozeDeletion")
|
||||
return
|
||||
f = self.fact.fields[self.currentField]
|
||||
f = self.note.fields[self.currentField]
|
||||
# find the highest existing cloze
|
||||
m = re.findall("\{\{c(\d+)::", f)
|
||||
if m:
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ you can enter it here. Use \\t to represent tab."""),
|
|||
self.parent.deck.finishProgress()
|
||||
self.parent.deck.setUndoEnd(n)
|
||||
txt = (
|
||||
_("Importing complete. %(num)d facts imported from %(file)s.\n") %
|
||||
_("Importing complete. %(num)d notes imported from %(file)s.\n") %
|
||||
{"num": self.importer.total, "file": os.path.basename(self.file)})
|
||||
self.dialog.groupBox.setShown(False)
|
||||
self.dialog.buttonBox.button(QDialogButtonBox.Close).setFocus()
|
||||
|
|
|
|||
24
aqt/main.py
24
aqt/main.py
|
|
@ -123,9 +123,9 @@ class AnkiQt(QMainWindow):
|
|||
def _editCurrentState(self, oldState):
|
||||
pass
|
||||
|
||||
def factChanged(self, fid):
|
||||
"Called when a card or fact is edited (but not deleted)."
|
||||
runHook("factChanged", fid)
|
||||
def noteChanged(self, nid):
|
||||
"Called when a card or note is edited (but not deleted)."
|
||||
runHook("noteChanged", nid)
|
||||
|
||||
# Resetting state
|
||||
##########################################################################
|
||||
|
|
@ -541,7 +541,7 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
|
|||
def closeEvent(self, event):
|
||||
"User hit the X button, etc."
|
||||
print "fixme: exit from edit current, review, etc"
|
||||
if self.state == "editCurrentFact":
|
||||
if self.state == "editCurrentNote":
|
||||
event.ignore()
|
||||
return self.moveToState("saveEdit")
|
||||
self.close(showBrowser=False)
|
||||
|
|
@ -602,11 +602,11 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
|
|||
def updateMarkAction(self, ):
|
||||
self.form.actionMarkCard.blockSignals(True)
|
||||
self.form.actionMarkCard.setChecked(
|
||||
self.reviewer.card.fact().hasTag("marked"))
|
||||
self.reviewer.card.note().hasTag("marked"))
|
||||
self.form.actionMarkCard.blockSignals(False)
|
||||
|
||||
def onMark(self, toggled):
|
||||
f = self.reviewer.card.fact()
|
||||
f = self.reviewer.card.note()
|
||||
if f.hasTag("marked"):
|
||||
f.delTag("marked")
|
||||
else:
|
||||
|
|
@ -623,9 +623,9 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
|
|||
self.deck.remCards([self.reviewer.card.id])
|
||||
self.reviewer.nextCard()
|
||||
|
||||
def onBuryFact(self):
|
||||
def onBuryNote(self):
|
||||
self.checkpoint(_("Bury"))
|
||||
self.deck.sched.buryFact(self.reviewer.card.fid)
|
||||
self.deck.sched.buryNote(self.reviewer.card.nid)
|
||||
self.reviewer.nextCard()
|
||||
|
||||
# Undo & autosave
|
||||
|
|
@ -690,7 +690,7 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
|
|||
|
||||
def onCardLayout(self):
|
||||
from aqt.clayout import CardLayout
|
||||
CardLayout(self, self.reviewer.card.fact(), type=1,
|
||||
CardLayout(self, self.reviewer.card.note(), type=1,
|
||||
ord=self.reviewer.card.ord)
|
||||
|
||||
def onDeckOpts(self):
|
||||
|
|
@ -829,7 +829,7 @@ Please choose a new deck name:"""))
|
|||
self.connect(m.actionGroups, s, self.onGroups)
|
||||
self.connect(m.actionDocumentation, s, self.onDocumentation)
|
||||
self.connect(m.actionDonate, s, self.onDonate)
|
||||
self.connect(m.actionBuryFact, s, self.onBuryFact)
|
||||
self.connect(m.actionBuryNote, s, self.onBuryNote)
|
||||
|
||||
def enableDeckMenuItems(self, enabled=True):
|
||||
"setEnabled deck-related items."
|
||||
|
|
@ -855,7 +855,7 @@ Please choose a new deck name:"""))
|
|||
self.form.actionMarkCard.setEnabled(False)
|
||||
self.form.actionSuspendCard.setEnabled(False)
|
||||
self.form.actionDelete.setEnabled(False)
|
||||
self.form.actionBuryFact.setEnabled(False)
|
||||
self.form.actionBuryNote.setEnabled(False)
|
||||
self.form.actionRepeatAudio.setEnabled(False)
|
||||
runHook("disableCardMenuItems")
|
||||
|
||||
|
|
@ -865,7 +865,7 @@ Please choose a new deck name:"""))
|
|||
self.form.actionMarkCard.setEnabled(True)
|
||||
self.form.actionSuspendCard.setEnabled(True)
|
||||
self.form.actionDelete.setEnabled(True)
|
||||
self.form.actionBuryFact.setEnabled(True)
|
||||
self.form.actionBuryNote.setEnabled(True)
|
||||
self.form.actionEditCurrent.setEnabled(True)
|
||||
self.form.actionEditdeck.setEnabled(True)
|
||||
self.updateMarkAction()
|
||||
|
|
|
|||
|
|
@ -59,8 +59,8 @@ class Models(QDialog):
|
|||
self.models = [self.deck.getModel(mid) for mid in mids]
|
||||
self.form.modelsList.clear()
|
||||
for m in self.models:
|
||||
item = QListWidgetItem(_("%(name)s [%(facts)d facts]") % dict(
|
||||
name=m.name, facts=m.useCount()))
|
||||
item = QListWidgetItem(_("%(name)s [%(notes)d notes]") % dict(
|
||||
name=m.name, notes=m.useCount()))
|
||||
self.form.modelsList.addItem(item)
|
||||
self.form.modelsList.setCurrentRow(row)
|
||||
|
||||
|
|
@ -78,23 +78,23 @@ class Models(QDialog):
|
|||
|
||||
def onLayout(self):
|
||||
# set to current
|
||||
# # see if there's an available fact
|
||||
# # see if there's an available note
|
||||
dummy = False
|
||||
id = self.deck.db.scalar(
|
||||
"select id from facts where mid = ?", self.model.id)
|
||||
"select id from notes where mid = ?", self.model.id)
|
||||
if id:
|
||||
fact = self.deck.getFact(id)
|
||||
note = self.deck.getNote(id)
|
||||
else:
|
||||
# generate a dummy one
|
||||
self.deck.conf['currentModelId'] = self.model.id
|
||||
fact = self.deck.newFact()
|
||||
for f in fact.keys():
|
||||
fact[f] = f
|
||||
self.deck.addFact(fact)
|
||||
note = self.deck.newNote()
|
||||
for f in note.keys():
|
||||
note[f] = f
|
||||
self.deck.addNote(note)
|
||||
dummy = True
|
||||
aqt.clayout.CardLayout(self.mw, fact, type=2, parent=self)
|
||||
aqt.clayout.CardLayout(self.mw, note, type=2, parent=self)
|
||||
if dummy:
|
||||
self.deck._delFacts([fact.id])
|
||||
self.deck._delNotes([note.id])
|
||||
|
||||
def onDelete(self):
|
||||
if len(self.models) < 2:
|
||||
|
|
|
|||
|
|
@ -402,7 +402,7 @@ div#filler {
|
|||
ord = self.typeAns()
|
||||
try:
|
||||
cor = self.mw.deck.media.strip(
|
||||
stripHTML(self.card.fact().fields[ord]))
|
||||
stripHTML(self.card.note().fields[ord]))
|
||||
except IndexError:
|
||||
self.card.template()['typeAns'] = None
|
||||
self.card.model().flush()
|
||||
|
|
|
|||
|
|
@ -54,14 +54,14 @@
|
|||
self.deck.updateProgress()
|
||||
d.s.statement("vacuum")
|
||||
self.deck.updateProgress()
|
||||
nfacts = d.factCount
|
||||
nnotes = d.noteCount
|
||||
mdir = self.deck.mediaDir()
|
||||
d.close()
|
||||
dir = os.path.dirname(path)
|
||||
zippath = os.path.join(dir, "shared-%d.zip" % time.time())
|
||||
# zip it up
|
||||
zip = zipfile.ZipFile(zippath, "w", zipfile.ZIP_DEFLATED)
|
||||
zip.writestr("facts", str(nfacts))
|
||||
zip.writestr("notes", str(nnotes))
|
||||
zip.writestr("version", str(2))
|
||||
readmep = os.path.join(dir, "README.html")
|
||||
readme = open(readmep, "w")
|
||||
|
|
|
|||
|
|
@ -388,8 +388,8 @@ firewall software temporarily, or try again from a different network.
|
|||
Debugging info: %s""") % error.data.get("exc", "<none>")
|
||||
else:
|
||||
tb = traceback.format_exc()
|
||||
if "missingFacts" in tb:
|
||||
msg=_("""Facts were missing after sync, so the \
|
||||
if "missingNotes" in tb:
|
||||
msg=_("""Notes were missing after sync, so the \
|
||||
sync was aborted. Please report this error.""")
|
||||
else:
|
||||
msg=_("Unknown error: %s") % tb
|
||||
|
|
|
|||
Loading…
Reference in a new issue