def test_activate_cards_5(self):
fact_data = {"f": "question", "b": "answer"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["b"])
fact_data = {"f": "question2", "b": "answer2"}
self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["a"])
assert self.database().active_count() == 2
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([
self.database().get_or_create_tag_with_name("a")._id,
self.database().get_or_create_tag_with_name("b")._id
])
c._tag_ids_forbidden = set(
[self.database().get_or_create_tag_with_name("b")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 1
def test_card_type(self):
from mnemosyne.libmnemosyne.card_types.cloze import ClozePlugin
for plugin in self.plugins():
if isinstance(plugin, ClozePlugin):
cloze_plugin = plugin
plugin.activate()
break
fact_data = {"text": "[foo]"}
card_type_1 = self.card_type_with_id("5")
card = self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["default"])[0]
assert self.database().active_count() == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = \
set([(card_type_1.id, card_type_1.fact_views[0].id)])
c._tag_ids_active = set()
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
self.controller().delete_facts_and_their_cards([card.fact])
plugin.deactivate()
c = self.database().current_criterion()
assert len(c.deactivated_card_type_fact_view_ids) == 0
def test_activate_cards_bulk_edit_2(self):
fact_data = {"f": "question", "b": "answer"}
card_type_1 = self.card_type_with_id("1")
card = self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["forbidden"])[0]
fact_data = {"f": "question2", "b": "answer2"}
card = self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["forbidden"])[0]
assert self.database().active_count() == 2
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("__UNTAGGED__")._id])
c._tag_ids_forbidden = set(
[self.database().get_or_create_tag_with_name("forbidden")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
self.database().remove_tag_from_cards_with_internal_ids(\
self.database().get_or_create_tag_with_name("forbidden"), [card._id])
assert self.database().active_count() == 1
def test_activate_cards_4(self):
fact_data = {"f": "question", "b": "answer"}
card_type_1 = self.card_type_with_id("1")
card = self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["tag"])[0]
self.review_controller().show_new_question()
assert self.review_controller().card == card
assert self.review_controller().counters() == (0, 1, 1)
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("tag2")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
self.review_controller().reset_but_try_to_keep_current_card()
self.review_controller().reload_counters()
assert self.review_controller().card is None
assert self.review_controller().counters() == (0, 0, 0)
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("tag")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
self.review_controller().reset_but_try_to_keep_current_card()
self.review_controller().reload_counters()
assert self.review_controller().card == card
assert self.review_controller().counters() == (0, 1, 1)
def test_inactive_parent(self):
fact_data = {"f": "question",
"b": "answer"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["dummy"])
fact_data = {"f": "question2",
"b": "answer2"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["a"])
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("dummy")._id])
c._tag_ids_forbidden = set([self.database().get_or_create_tag_with_name("a")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 1
fact_data = {"f": "question3",
"b": "answer3"}
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["a::b"])
assert self.database().active_count() == 1
fact_data = {"f": "question4",
"b": "answer4"}
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["dummy::b"])
assert self.database().active_count() == 2
def test_empty_criterion(self):
c = Criterion(self.mnemosyne.component_manager)
assert c.is_empty() == False
tag_id = self.database().get_or_create_tag_with_name("a")._id
c = DefaultCriterion(self.mnemosyne.component_manager)
for card_type in self.card_types():
for fact_view in card_type.fact_views:
c.deactivated_card_type_fact_view_ids.add(
(card_type.id, fact_view.id))
c._tag_ids_active = set([])
c._tag_ids_forbidden = set()
assert c.is_empty() == True
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([])
c._tag_ids_forbidden = set()
assert c.is_empty() == True
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(["__UNTAGGED__"])
c._tag_ids_forbidden = set([tag_id])
assert c.is_empty() == False
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(["__UNTAGGED__"])
c._tag_ids_forbidden = set([tag_id, "__UNTAGGED__"])
assert c.is_empty() == True
def test_card_type(self):
from mnemosyne.libmnemosyne.card_types.cloze import ClozePlugin
for plugin in self.plugins():
if isinstance(plugin, ClozePlugin):
cloze_plugin = plugin
plugin.activate()
break
fact_data = {"text": "[foo]"}
card_type_1 = self.card_type_with_id("5")
card = self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["default"])[0]
assert self.database().active_count() == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = \
set([(card_type_1.id, card_type_1.fact_views[0].id)])
c._tag_ids_active = set()
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
self.controller().delete_facts_and_their_cards([card.fact])
plugin.deactivate()
c = self.database().current_criterion()
assert len(c.deactivated_card_type_fact_view_ids) == 0
def test_activate_cards_3(self):
fact_data = {"f": "question",
"b": "answer"}
card_type_1 = self.card_type_with_id("1")
card = self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["tag1"])[0]
self.review_controller().show_new_question()
assert self.review_controller().card == card
assert self.review_controller().counters() == (0, 1, 1)
fact_data = {"f": "question2",
"b": "answer2"}
card_type_2 = self.card_type_with_id("2")
cards = self.controller().create_new_cards(fact_data, card_type_2,
grade=-1, tag_names=["tag2"])
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("tag2")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
self.review_controller().reset_but_try_to_keep_current_card()
self.review_controller().reload_counters()
assert self.review_controller().card != card
assert self.review_controller().counters() == (0, 2, 2)
def test_activate_cards_edit(self):
fact_data = {"f": "question3", "b": "answer3"}
card_type_1 = self.card_type_with_id("1")
card = self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["forbidden"])[0]
assert self.database().active_count() == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("forbidden")._id])
c._tag_ids_forbidden = set(
[self.database().get_or_create_tag_with_name("forbidden")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
card_type_2 = self.card_type_with_id("2")
self.controller().edit_card_and_sisters(card,
card.fact.data,
card_type_2,
new_tag_names=["allowed"],
correspondence=[])
assert self.database().active_count() == 2
c = list(self.database().criteria())[0]
assert len(c._tag_ids_forbidden) == 0
assert len(c._tag_ids_active) == 1
def __init__(self, **kwds):
super().__init__(**kwds)
self.parent = kwds["parent"]
component_manager = kwds["component_manager"]
self.setupUi(self)
self.card_type_tree_wdgt = CardTypesTreeWdgt(\
component_manager=component_manager, parent=self)
# Bug in Qt: need to explicitly reset the text of this label.
self.label.setText(_("Activate cards from these card types:"))
self.gridLayout.addWidget(self.card_type_tree_wdgt, 1, 0)
self.tag_tree_wdgt = TagsTreeWdgt(\
component_manager=component_manager, parent=self)
self.gridLayout.addWidget(self.tag_tree_wdgt, 1, 1)
criterion = DefaultCriterion(component_manager=self.component_manager)
for tag in self.database().tags():
criterion._tag_ids_active.add(tag._id)
self.display_criterion(criterion)
self.card_type_tree_wdgt.tree_wdgt.\
itemChanged.connect(self.criterion_changed)
self.tag_tree_wdgt.tree_wdgt.\
itemChanged.connect(self.criterion_changed)
self.card_type_tree_wdgt.tree_wdgt.\
itemClicked.connect(self.criterion_clicked)
self.tag_tree_wdgt.tree_wdgt.\
itemClicked.connect(self.criterion_clicked)
def criterion_from_log_entry(self, log_entry):
# Get criterion object to be deleted now.
if log_entry["type"] == EventTypes.DELETED_CRITERION:
return self.criterion(log_entry["o_id"], is_id_internal=False)
# Create an empty shell of criterion object that will be deleted later
# during this sync.
if "criterion_type" not in log_entry:
from mnemosyne.libmnemosyne.criteria.default_criterion \
import DefaultCriterion
return DefaultCriterion(self.component_manager, log_entry["o_id"])
# Create criterion object.
for criterion_class in self.component_manager.all("criterion"):
if criterion_class.criterion_type == log_entry["criterion_type"]:
criterion = \
criterion_class(self.component_manager, log_entry["o_id"])
criterion.name = log_entry["name"]
# Try to apply the data to the criterion. If this fails, it
# means that the data to do this is not yet available at this
# stage of the sync, and will be corrected by a later
# EDITED_CRITERION event.
try:
criterion.set_data_from_sync_string(log_entry["data"])
except TypeError:
pass
if log_entry["type"] != EventTypes.ADDED_CRITERION:
criterion._id = self.con.execute(
"""select _id from criteria where
id=?""", (criterion.id, )).fetchone()[0]
return criterion
def display(self, criterion=None):
# Create criterion if needed.
if criterion is None:
criterion = DefaultCriterion(self.component_manager)
# Determine number of cards at each level of the tree.
root_count = 0
count_for_card_type = {}
count_for_fact_view = {}
for card_type in self.card_types():
card_type_count = 0
for fact_view in card_type.fact_views:
count = self.database().card_count_for_fact_view \
(fact_view, active_only=False)
card_type_count += count
count_for_fact_view[fact_view] = count
count_for_card_type[card_type] = card_type_count
root_count += card_type_count
# Fill widget.
self.nodes_which_can_be_deleted = []
self.nodes_which_can_be_renamed = []
self.tree_wdgt.clear()
self.card_type_fact_view_ids_for_node_item = {}
root_item = QtGui.QTreeWidgetItem(
self.tree_wdgt, [_("All card types (%d)") % root_count], 0)
root_item.setFlags(root_item.flags() | \
QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsTristate)
root_item.setCheckState(0, QtCore.Qt.Checked)
for card_type in self.database().sorted_card_types():
card_type_item = QtGui.QTreeWidgetItem(root_item, ["%s (%d)" % \
(_(card_type.name), count_for_card_type[card_type])], 0)
card_type_item.setFlags(card_type_item.flags() | \
QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsTristate)
card_type_item.setCheckState(0, QtCore.Qt.Checked)
card_type_item.setData(
NODE, QtCore.Qt.DisplayRole,
QtCore.QVariant(QtCore.QString(card_type.id)))
if count_for_card_type[card_type] == 0 and \
self.database().is_user_card_type(card_type):
self.nodes_which_can_be_deleted.append(card_type.id)
if self.database().is_user_card_type(card_type):
self.nodes_which_can_be_renamed.append(card_type.id)
card_type_item.setFlags(card_type_item.flags() | \
QtCore.Qt.ItemIsEditable)
for fact_view in card_type.fact_views:
fact_view_item = QtGui.QTreeWidgetItem(card_type_item, [
"%s (%d)" %
(_(fact_view.name), count_for_fact_view[fact_view])
], 0)
fact_view_item.setFlags(fact_view_item.flags() | \
QtCore.Qt.ItemIsUserCheckable)
if (card_type.id, fact_view.id) in \
criterion.deactivated_card_type_fact_view_ids:
check_state = QtCore.Qt.Unchecked
else:
check_state = QtCore.Qt.Checked
fact_view_item.setCheckState(0, check_state)
self.card_type_fact_view_ids_for_node_item[fact_view_item] = \
(card_type.id, fact_view.id)
self.tree_wdgt.expandAll()
def test_reset_but_try_to_keep_current_card_turned_inactive(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "1", "b": "b"}
card = self.controller().create_new_cards(fact_data, card_type, grade=-1, tag_names=["forbidden"])[0]
self.review_controller().show_new_question()
assert self.review_controller().card == card
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("active")._id])
c._tag_ids_forbidden = set([self.database().get_or_create_tag_with_name("forbidden")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
assert self.review_controller().card == card
self.review_controller().reset_but_try_to_keep_current_card()
assert self.review_controller().card is None
def restore_criterion(self):
new_criterion = DefaultCriterion(self.component_manager)
for tag in self.database().tags():
if tag._id in self.saved_criterion._tag_ids_active or \
tag._id not in self.saved_criterion._tag_ids_forbidden:
# Second case deals with recently added tag.
new_criterion._tag_ids_active.add(tag._id)
self.display(new_criterion)
def test_cached_scheduler_count(self):
fact_data = {"f": "question",
"b": "answer"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["tag"])
assert self.database().active_count() == 1
self.review_controller().show_new_question()
assert self.review_controller().active_count == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set()
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
self.review_controller().reset_but_try_to_keep_current_card()
assert self.database().active_count() == 0
assert self.review_controller().active_count == 0
def update_filter(self, dummy=None):
# Card types and fact views.
criterion = DefaultCriterion(self.component_manager)
self.card_type_tree_wdgt.checked_to_criterion(criterion)
filter = ""
for card_type_id, fact_view_id in \
criterion.deactivated_card_type_fact_view_ids:
filter += """not (cards.fact_view_id='%s' and
cards.card_type_id='%s') and """ \
% (fact_view_id, card_type_id)
filter = filter.rsplit("and ", 1)[0]
# Tags.
self.tag_tree_wdgt.checked_to_active_tags_in_criterion(criterion)
if len(criterion._tag_ids_active) == 0:
filter = "_id='not_there'"
elif len(criterion._tag_ids_active) != self.tag_count:
if filter:
filter += "and "
# Determine all _card_ids.
query = QtSql.QSqlQuery("select _id from cards")
all__card_ids = set()
while query.next():
all__card_ids.add(str(query.value(0)))
# Determine _card_ids of card with an active tag.
if self.any_all_tags.currentIndex() == 0:
query = "select _card_id from tags_for_card where _tag_id in ("
for _tag_id in criterion._tag_ids_active:
query += "'%s', " % (_tag_id, )
query = query[:-2] + ")"
# Determine _card_ids of cards which have all active tags.
else:
query = ""
for _tag_id in criterion._tag_ids_active:
query += "select _card_id from tags_for_card where " + \
"_tag_id='%s' intersect " % (_tag_id, )
query = query[:-(len(" intersect "))]
query = QtSql.QSqlQuery(query)
active__card_ids = set()
while query.next():
active__card_ids.add(str(query.value(0)))
# Construct most optimal query.
if len(active__card_ids) > len(all__card_ids) / 2:
filter += "_id not in (" + \
",".join(all__card_ids - active__card_ids) + ")"
else:
filter += "_id in (" + ",".join(active__card_ids) + ")"
# Search string.
search_string = self.search_box.text().replace("'", "''")
self.card_model.search_string = search_string
if search_string:
if filter:
filter += " and "
filter += "(question like '%%%s%%' or answer like '%%%s%%')" \
% (search_string, search_string)
self.card_model.setFilter(filter)
self.card_model.select()
self.update_card_counters()
def test_delete_forbidden(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question", "b": "answer"}
card = self.controller().create_new_cards(fact_data, card_type,
grade=-1, tag_names=["forbidden"])[0]
assert self.database().active_count() == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("active")._id, 1])
c._tag_ids_forbidden = set([self.database().get_or_create_tag_with_name("forbidden")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
self.tree.delete_subtree("forbidden")
assert self.database().active_count() == 1
def display(self, criterion=None):
# Create criterion if needed.
if criterion is None:
criterion = DefaultCriterion(self.component_manager)
for tag in self.database().tags():
criterion._tag_ids_active.add(tag._id)
# Create tree.
self.tag_tree = TagTree(self.component_manager)
self.tree_wdgt.clear()
self.node_items = []
self.tag_for_node_item = []
self.nodes_which_can_be_deleted = []
self.nodes_which_can_be_renamed = []
node = "__ALL__"
node_name = "%s (%d)" % (self.tag_tree.display_name_for_node[node],
self.tag_tree.card_count_for_node[node])
root = self.tag_tree[node]
root_item = QtWidgets.QTreeWidgetItem(\
self.tree_wdgt, [node_name, node], 0)
root_item.setFlags(root_item.flags() | \
QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsTristate)
root_item.setCheckState(0, QtCore.Qt.Checked)
self.create_tree(self.tag_tree[node], qt_parent=root_item)
# Set forbidden tags.
if len(criterion._tag_ids_forbidden):
for i in range(len(self.node_items)):
node_item = self.node_items[i]
tag = self.tag_for_node_item[i]
if tag._id in criterion._tag_ids_forbidden:
node_item.setCheckState(0, QtCore.Qt.Checked)
else:
node_item.setCheckState(0, QtCore.Qt.Unchecked)
# Set active tags.
else:
# We first set all the tags inactive. We cannot do this in the
# second branch of the upcoming 'if' statement, as then an
# inactive parent tag coming later in the list will deactivate
# active child tags coming earlier in the list.
for node_item in self.node_items:
node_item.setCheckState(0, QtCore.Qt.Unchecked)
for i in range(len(self.node_items)):
node_item = self.node_items[i]
tag = self.tag_for_node_item[i]
if tag._id in criterion._tag_ids_active:
node_item.setCheckState(0, QtCore.Qt.Checked)
# Restore state of the tree.
self.tree_wdgt.expandAll()
collapsed = self.config()["tag_tree_wdgt_state"]
if collapsed is None:
collapsed = []
iterator = QtWidgets.QTreeWidgetItemIterator(self.tree_wdgt)
while iterator.value():
if iterator.value().text(1) in collapsed:
iterator.value().setExpanded(False)
iterator += 1
def test_activate_cards_new_2(self):
fact_data = {"f": "question",
"b": "answer"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["default"])
assert self.database().active_count() == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = \
set([(card_type_1.id, card_type_1.fact_views[0].id)])
c._tag_ids_active = set()
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
fact_data = {"f": "question2",
"b": "answer2"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["default"])
assert self.database().active_count() == 0
def test_delete_forbidden(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question", "b": "answer"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["forbidden"])[0]
assert self.database().active_count() == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("active")._id, 1])
c._tag_ids_forbidden = set(
[self.database().get_or_create_tag_with_name("forbidden")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
self.tree.delete_subtree("forbidden")
assert self.database().active_count() == 1
def test_reset_but_try_to_keep_current_card_turned_inactive(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "1", "b": "b"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["forbidden"])[0]
self.review_controller().show_new_question()
assert self.review_controller().card == card
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("active")._id])
c._tag_ids_forbidden = set(
[self.database().get_or_create_tag_with_name("forbidden")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
assert self.review_controller().card == card
self.review_controller().reset_but_try_to_keep_current_card()
assert self.review_controller().card is None
def activate():
from mnemosyne.libmnemosyne.criteria.default_criterion import \
DefaultCriterion
card_type_2 = mnemosyne.card_type_with_id("2")
c = DefaultCriterion(mnemosyne.component_manager)
c._tag_ids_active = set([mnemosyne.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id)])
c._tag_ids_active = set([mnemosyne.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
mnemosyne.database().set_current_criterion(c)
def test_activate_cards_edit(self):
fact_data = {"f": "question3",
"b": "answer3"}
card_type_1 = self.card_type_with_id("1")
card = self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["forbidden"])[0]
assert self.database().active_count() == 1
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("forbidden")._id])
c._tag_ids_forbidden = set([self.database().get_or_create_tag_with_name("forbidden")._id])
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
card_type_2 = self.card_type_with_id("2")
self.controller().edit_card_and_sisters(card, card.fact.data,
card_type_2, new_tag_names=["allowed"], correspondence=[])
assert self.database().active_count() == 2
c = list(self.database().criteria())[0]
assert len(c._tag_ids_forbidden) == 0
assert len(c._tag_ids_active) == 1
def activate():
from mnemosyne.libmnemosyne.criteria.default_criterion import \
DefaultCriterion
card_type_2 = mnemosyne.card_type_with_id("2")
c = DefaultCriterion(mnemosyne.component_manager)
c._tag_ids_active = set([mnemosyne.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id)])
c._tag_ids_active = set([mnemosyne.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
mnemosyne.database().set_current_criterion(c)
def criterion(self):
"""Build the criterion from the information the user entered in the
widget.
"""
criterion = DefaultCriterion(component_manager=self.component_manager)
criterion = self.card_type_tree_wdgt.checked_to_criterion(criterion)
# Tag tree contains active tags.
if self.active_or_forbidden.currentIndex() == 0:
self.tag_tree_wdgt.checked_to_active_tags_in_criterion(criterion)
# Tag tree contains forbidden tags.
else:
self.tag_tree_wdgt.\
checked_to_forbidden_tags_in_criterion(criterion)
for tag in self.database().tags():
criterion._tag_ids_active.add(tag._id)
return criterion
def test_compare_criteria(self):
c1 = DefaultCriterion(self.mnemosyne.component_manager)
c1.deactivated_card_type_fact_view_ids = set()
c1._tag_ids_active = set([self.database().get_or_create_tag_with_name("default")._id])
c1._tag_ids_forbidden = set()
c2 = DefaultCriterion(self.mnemosyne.component_manager)
c2.deactivated_card_type_fact_view_ids = set()
c2._tag_ids_active = set([self.database().get_or_create_tag_with_name("default")._id])
c2._tag_ids_forbidden = set()
c3 = DefaultCriterion(self.mnemosyne.component_manager)
c3.deactivated_card_type_fact_view_ids = set()
c3._tag_ids_active = set([self.database().get_or_create_tag_with_name("default1")._id])
c3._tag_ids_forbidden = set()
assert c1 == c2
assert c1 != c3
assert c1 != 1
def save_criterion(self):
self.saved_criterion = DefaultCriterion(self.component_manager)
self.checked_to_criterion(self.saved_criterion)
def test_activate_cards_1(self):
fact_data = {"f": "question",
"b": "answer"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data, card_type_1,
grade=-1, tag_names=["default"])
assert self.database().active_count() == 1
fact_data = {"f": "question",
"b": "answer"}
card_type_2 = self.card_type_with_id("2")
self.controller().create_new_cards(fact_data, card_type_2,
grade=-1, tag_names=["default"])
assert self.database().active_count() == 3
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 3
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id)])
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 2
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("default2")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
fact_data = {"f": "question2",
"b": "answer2"}
self.controller().create_new_cards(fact_data, card_type_2,
grade=-1, tag_names=["default2"])
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("default2")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 2
fact_data = {"f": "question3",
"b": "answer3"}
self.controller().create_new_cards(fact_data, card_type_2,
grade=-1, tag_names=["default3",
"default4"])
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("default3")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 2
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id)])
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("default3")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 1
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id),
(card_type_2.id, card_type_2.fact_views[1].id)])
c._tag_ids_active = set([self.database().get_or_create_tag_with_name("default3")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
def do_import(self, filename, extra_tag_names=""):
self.main_widget().show_information(_(\
"Note that while you can edit imported cards, adding new cards to Anki's card types is currently not supported.\n\nAlso, in case you run into problems, don't hesitate to contact the developers."))
FileFormat.do_import(self, filename, extra_tag_names)
w = self.main_widget()
db = self.database()
# Preprocess apkg files.
tmp_dir = None
if filename.endswith(".apkg"):
tmp_dir = self.extract_apkg(filename)
filename = os.path.join(tmp_dir, "collection.anki2")
# Set up tag cache.
tag_with_name = TagCache(self.component_manager)
# Open database.
con = sqlite3.connect(filename)
# Copy media directory.
w.set_progress_text(_("Copying media files..."))
src = filename.replace(".anki2", ".media")
dst = db.media_dir()
number_of_files = len(os.listdir(src))
w.set_progress_range(number_of_files)
w.set_progress_update_interval(number_of_files / 50)
for item in os.listdir(src):
shutil.copy(os.path.join(src, item), os.path.join(dst, item))
w.increase_progress(1)
# Import collection table.
w.set_progress_text(_("Importing card types..."))
# Too few in number to warrant counted progress bar.
card_type_for_mid = {} # mid: model id
deck_name_for_did = {} # did: deck id
for id, crt, mod, scm, ver, dty, usn, ls, conf, models, decks, \
dconf, tags in con.execute("""select id, crt, mod, scm, ver, dty,
usn, ls, conf, models, decks, dconf, tags from col"""):
# mod: modification time, ignore.
# scm: schema modification time, ignore.
# ver: schema version, ignore.
# dty: no longer used according to Anki source.
# usn: syncing related, ignore.
# ls: last sync, ignore.
# conf: configuration, ignore.
# dconf: deck configuration, ignore.
# tags: list of tags, but they turn up later in the notes, ignore.
collection_creation_time = crt
decks = json.loads(decks)
# Decks will be converted to Tags when creating cards.
for did in decks:
deck_name_for_did[int(did)] = decks[did]["name"]
# Models will be converted to CardTypes
models = json.loads(models)
for mid in models: # mid: model id
card_type_id = "7::" + mid
card_type_already_imported = \
db.has_card_type_with_id(card_type_id)
if card_type_already_imported:
card_type = self.component_manager.card_type_with_id[\
card_type_id]
else:
card_type = MSided(self.component_manager)
card_type.name = models[mid]["name"]
card_type.id = card_type_id
card_type.hidden_from_UI = False
card_type_for_mid[int(mid)] = card_type
vers = models[mid]["vers"] # Version, ignore.
tags = models[mid]["tags"] # Seems empty, ignore.
did = models[mid]["did"] # Deck id, ignore.
usn = models[mid]["usn"] # Syncing related, ignore.
if "req" in models[mid]:
required = models[mid]["req"]
# Cache for a calculation to determine which fields are
# required. "req": [[0, "all", [0]]]
# Not yet implemented.
else:
required = []
flds = models[mid]["flds"]
flds.sort(key=lambda x: x["ord"])
card_type.fact_keys_and_names = []
for field in flds:
card_type.fact_keys_and_names.append(\
(str(field["ord"]), field["name"]))
media = field["media"] # Reserved for future use, ignore.
sticky = field["sticky"] # Sticky field, ignore.
rtl = field["rtl"] # Text direction, ignore.
font_string = field["font"] + "," + str(field["size"]) + \
",-1,5,50,0,0,0,0,0,Regular"
self.config().set_card_type_property(
"font", font_string, card_type, str(field["ord"]))
sortf = models[mid]["sortf"] # Sorting field, ignore.
tmpls = models[mid]["tmpls"]
tmpls.sort(key=lambda x: x["ord"])
# Fact views.
card_type.fact_views = []
for template in tmpls:
fact_view_id = card_type.id + "." + str(template["ord"])
fact_view_already_imported = \
db.has_fact_view_with_id(fact_view_id)
if fact_view_already_imported:
fact_view = db.fact_view(\
fact_view_id, is_id_internal=False)
fact_view.name = template["name"]
else:
fact_view = FactView(template["name"], fact_view_id)
fact_view.extra_data["qfmt"] = template["qfmt"]
fact_view.extra_data["afmt"] = template["afmt"]
fact_view.extra_data["bqfmt"] = template["bqfmt"]
fact_view.extra_data["bafmt"] = template["bafmt"]
fact_view.extra_data["ord"] = template["ord"]
did = template["did"] # Deck id, ignore.
card_type.fact_views.append(fact_view)
if fact_view_already_imported:
db.update_fact_view(fact_view)
else:
db.add_fact_view(fact_view)
mod = models[mid]["mod"] # Modification time, ignore.
type_ = models[mid]["type"] # 0: standard, 1 cloze
id = models[mid]["id"]
css = models[mid]["css"]
latex_preamble = models[mid]["latexPre"] # Ignore.
latex_postamble = models[mid]["latexPost"] # Ignore.
# Save to database.
card_type.extra_data = {"css": css, "id": id, "type": type_}
if card_type_already_imported:
db.update_card_type(card_type)
else:
db.add_card_type(card_type)
# nid are Anki-internal indices for notes, so we need to temporarily
# store some information.
tag_names_for_nid = {}
card_type_for_nid = {}
# Import facts and tags.
w.set_progress_text(_("Importing notes..."))
number_of_notes = con.execute(
"select count() from notes").fetchone()[0]
w.set_progress_range(number_of_notes)
w.set_progress_update_interval(number_of_notes / 20)
fact_for_nid = {}
modification_time_for_nid = {}
for id, guid, mid, mod, usn, tags, flds, sfld, csum, flags, data in \
con.execute("""select id, guid, mid, mod, usn, tags, flds, sfld,
csum, flags, data from notes"""):
# usn: syncing related, ignore.
# sfld: sorting field, ignore.
# csum: checksum, ignore.
# flags: seems empty, ignore.
# data: seems empty, ignore.
# Make compatible with openSM2sync:
guid = guid.replace("`", "ap").replace("\"", "qu")
guid = guid.replace("&", "am").replace("<",
"lt").replace(">", "gt")
modification_time_for_nid[id] = mod
card_type = card_type_for_mid[int(mid)]
card_type_for_nid[id] = card_type
fields = flds.split("\x1f")
assert (len(fields) == len(card_type.fact_keys_and_names))
fact_data = {}
for i in range(len(fields)):
fact_key = card_type.fact_keys_and_names[i][0]
data = fields[i]
# Deal with sound tags.
for match in sound_re.finditer(data):
fname = match.group("fname")
data = data.replace(\
match.group(0), "<audio src=\"" + fname + "\">")
# Deal with latex tags.
data = data.replace("[latex]", "<latex>")
data = data.replace("[/latex]", "</latex>")
data = data.replace("[$]", "<$>")
data = data.replace("[/$]", "</$>")
data = data.replace("[$$]", "<$$>")
data = data.replace("[/$$]", "</$$>")
fact_data[fact_key] = data
if db.has_fact_with_id(guid):
fact = db.fact(guid, is_id_internal=False)
fact.data = fact_data
db.update_fact(fact)
else:
fact = Fact(fact_data, id=guid)
db.add_fact(fact)
fact_for_nid[id] = fact
tag_names_for_nid[id] = tags
w.increase_progress(1)
# Import logs. This needs to happen before creating the cards,
# otherwise, the sync protocol will use the scheduling data from the
# latest repetition log, instead of the correct current one.
w.set_progress_text(_("Importing logs..."))
number_of_logs = con.execute(
"select count() from revlog").fetchone()[0]
w.set_progress_range(number_of_logs)
w.set_progress_update_interval(number_of_logs / 20)
for id, cid, usn, ease, ivl, lastIvl, factor, time, type_ in \
con.execute("""select id, cid, usn, ease, ivl, lastIvl, factor,
time, type from revlog"""):
# usn: syncing related, ignore.
if type_ == 0: # Acquisition phase.
grade = 0
else: # Retention phase.
grade = ease + 1 # Anki ease is from 1 to 4.
timestamp = int(id / 1000)
scheduled_interval = lastIvl * 86400 if lastIvl > 0 else 0
new_interval = ivl * 86400 if ivl > 0 else 0
next_rep = timestamp + new_interval
easiness = factor / 1000 if factor else 2.5
db.log_repetition(timestamp=timestamp,
card_id=cid,
grade=grade,
easiness=easiness,
acq_reps=0,
ret_reps=0,
lapses=0,
acq_reps_since_lapse=0,
ret_reps_since_lapse=0,
scheduled_interval=scheduled_interval,
actual_interval=scheduled_interval,
thinking_time=int(time / 1000),
next_rep=next_rep,
scheduler_data=0)
w.increase_progress(1)
# Import cards.
w.set_progress_text(_("Importing cards..."))
number_of_cards = con.execute(
"select count() from cards").fetchone()[0]
w.set_progress_range(number_of_cards)
w.set_progress_update_interval(number_of_cards / 20)
for id, nid, did, ord, mod, usn, type_, queue, due, ivl, factor, reps, \
lapses, left, odue, odid, flags, data in con.execute("""select id,
nid, did, ord, mod, usn, type, queue, due, ivl, factor, reps,
lapses, left, odue, odid, flags, data from cards"""):
# type: 0=new, 1=learning, 2=due
# queue: same as above, and -1=suspended,
# -2=user buried, -3=sched buried
# due is used differently for different queues.
# - new queue: note id or random int
# - rev queue: integer day
# - lrn queue: integer timestamp
# In Mnemosyne, type=2 / rev queue corresponds to grades >= 2.
# mod: modification time, but gets updated on each answer.
# usn: syncing related, ignore.
# left: repetitions left to graduation, ignore.
# odue: original due, related to filtered decks, ignore.
# odid: original deck id, related to filtered decks, ignore.
# flags: seems empty, ignore.
# data: seems empty, ignore
fact = fact_for_nid[nid]
card_type = card_type_for_nid[nid]
creation_time = int(nid / 1000)
if card_type.extra_data["type"] == 0:
fact_view = card_type.fact_views[ord]
else: # Cloze.
fact_view = card_type.fact_views[0]
already_imported = db.has_card_with_id(id)
if already_imported:
card = db.card(id, is_id_internal=False)
card.card_type = card_type
card.fact = fact
card.fact_view = fact_view
card.creation_time = creation_time
else:
card = Card(card_type,
fact,
fact_view,
creation_time=creation_time)
card.id = id
card.extra_data["ord"] = ord # Needed separately for clozes.
tag_names = [tag_name.strip() for \
tag_name in extra_tag_names.split(",")]
tag_names += [tag_name.strip() for \
tag_name in tag_names_for_nid[nid].split(" ")]
tag_names += [deck_name_for_did[did].strip().replace(",", ";")]
for tag_name in tag_names:
if tag_name:
card.tags.add(tag_with_name[tag_name])
card.next_rep = collection_creation_time + due * 86400
card.last_rep = card.next_rep - ivl * 86400
card.easiness = factor / 1000 if factor else 2.5
card.acq_reps = 1 # No information.
card.ret_reps = reps
card.lapses = lapses
card.acq_reps_since_lapse = card.acq_reps # No information.
card.ret_reps_since_lapse = card.ret_reps # No information.
card.modification_time = modification_time_for_nid[nid]
self.active = (queue >= 0)
if type_ == 0: # 'new', unseen.
card.reset_learning_data()
elif type_ == 1: # 'learning', acquisition phase.
card.grade = 0
card.last_rep = mod
card.next_rep = mod
else: # 'due', retention phase.
card.grade = 4 # No information.
if card.grade >= 2:
assert card.ret_reps_since_lapse != 0 # Issue #93 on github.
if already_imported:
db.update_card(card)
else:
db.add_card(card)
w.increase_progress(1)
# Create criteria for 'database' tags.
for deck_name in deck_name_for_did.values():
deck_name = deck_name.strip().replace(",", ";")
if deck_name in [criterion.name for criterion in db.criteria()]:
continue
tag = tag_with_name[deck_name]
criterion = DefaultCriterion(\
component_manager=self.component_manager)
criterion.name = deck_name
criterion._tag_ids_active.add(tag._id)
criterion._tag_ids_forbidden = set()
db.add_criterion(criterion)
# Clean up.
con.close()
if tmp_dir:
shutil.rmtree(tmp_dir)
w.close_progress()
self.warned_about_missing_media = False
def test_activate_cards_1(self):
fact_data = {"f": "question", "b": "answer"}
card_type_1 = self.card_type_with_id("1")
self.controller().create_new_cards(fact_data,
card_type_1,
grade=-1,
tag_names=["default"])
assert self.database().active_count() == 1
fact_data = {"f": "question", "b": "answer"}
card_type_2 = self.card_type_with_id("2")
self.controller().create_new_cards(fact_data,
card_type_2,
grade=-1,
tag_names=["default"])
assert self.database().active_count() == 3
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 3
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id)])
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 2
c = DefaultCriterion(self.mnemosyne.component_manager)
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default2")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
fact_data = {"f": "question2", "b": "answer2"}
self.controller().create_new_cards(fact_data,
card_type_2,
grade=-1,
tag_names=["default2"])
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default2")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 2
fact_data = {"f": "question3", "b": "answer3"}
self.controller().create_new_cards(fact_data,
card_type_2,
grade=-1,
tag_names=["default3", "default4"])
c.deactivated_card_type_fact_view_ids = set()
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default3")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 2
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id)])
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default3")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 1
c.deactivated_card_type_fact_view_ids = \
set([(card_type_2.id, card_type_2.fact_views[0].id),
(card_type_2.id, card_type_2.fact_views[1].id)])
c._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default3")._id])
c._tag_ids_forbidden = set()
self.database().set_current_criterion(c)
assert self.database().active_count() == 0
def save_criterion(self):
self.saved_criterion = DefaultCriterion(self.component_manager)
self.checked_to_active_tags_in_criterion(self.saved_criterion)
# We also save the unchecked tags as this will allow us to identify
# any new tags created afterwards.
self.unchecked_to_forbidden_tags_in_criterion(self.saved_criterion)
def test_compare_criteria(self):
c1 = DefaultCriterion(self.mnemosyne.component_manager)
c1.deactivated_card_type_fact_view_ids = set()
c1._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default")._id])
c1._tag_ids_forbidden = set()
c2 = DefaultCriterion(self.mnemosyne.component_manager)
c2.deactivated_card_type_fact_view_ids = set()
c2._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default")._id])
c2._tag_ids_forbidden = set()
c3 = DefaultCriterion(self.mnemosyne.component_manager)
c3.deactivated_card_type_fact_view_ids = set()
c3._tag_ids_active = set(
[self.database().get_or_create_tag_with_name("default1")._id])
c3._tag_ids_forbidden = set()
assert c1 == c2
assert c1 != c3
assert c1 != 1
