def test_two_mem_files_sharing_same_logs(self):
filename = os.path.join(os.getcwd(), "tests", "files", "basedir_2_mem",
"deck1.mem")
self.mem_importer().do_import(filename)
assert self.database().con.execute(\
"select count() from log where event_type=?",
(EventTypes.REPETITION, )).fetchone()[0] == 1
filename = os.path.join(os.getcwd(), "tests", "files", "basedir_2_mem",
"deck2.mem")
self.mem_importer().do_import(filename)
assert self.database().con.execute(\
"select count() from log where event_type=?",
(EventTypes.REPETITION, )).fetchone()[0] == 3
assert self.database().con.execute(\
"select count() from log where event_type=?",
(EventTypes.ADDED_CARD, )).fetchone()[0] == 2
card = self.database().card("4c8fff73", is_id_internal=False)
assert self.database().average_thinking_time(card) == 1.5
assert self.database().total_thinking_time(card) == 3.0
assert self.database().card_count_for_grade(0, active_only=True) == 2
tag = self.database().get_or_create_tag_with_name("666")
assert self.database().card_count_for_grade_and_tag(
0, tag, active_only=True) == 0
from mnemosyne.libmnemosyne.statistics_pages.grades import Grades
page = Grades(component_manager=self.mnemosyne.component_manager)
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tag_tree = TagTree(self.mnemosyne.component_manager,
count_cards=False)
self.nodes = self.tag_tree.nodes()
for index, node in enumerate(self.nodes):
if node == "666":
page.prepare_statistics(index)
assert page.y == [0, 0, 0, 0, 0, 0, 0]
page.prepare_statistics(-1)
assert page.y == [0, 2, 0, 0, 0, 0, 0]
def __init__(self, **kwds):
super().__init__(**kwds)
self.tag_tree = TagTree(self.component_manager, count_cards=False)
self.nodes = self.tag_tree.nodes()
self.variants = [(self.ALL_CARDS, _("All cards")),
(self.ACTIVE_CARDS, _("Active cards only"))]
for index, node in enumerate(self.nodes):
if node == "__UNTAGGED__":
node = _("Untagged")
self.variants.append((index, node))
def rebuild(self):
"""To be called when external events invalidate the tag tree,
e.g. due to edits in the card browser widget.
"""
self.save_criterion()
self.store_tree_state()
self.tag_tree = TagTree(self.component_manager)
self.restore_criterion()
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_delete_2(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question4", "b": "answer4"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["a::b"])[0]
fact_data = {"f": "question", "b": "answer"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["a"])[0]
fact_data = {"f": "question2", "b": "answer2"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["Z"])[0]
fact_data = {"f": "question3", "b": "answer3"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["a::c"])[0]
fact_data = {"f": "question5", "b": "answer5"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["b::c::d",
"b"])[0]
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
assert self.tree.card_count_for_node["__ALL__"] == 5
assert self.tree.card_count_for_node["a"] == 3
assert self.tree.card_count_for_node["Z"] == 1
assert self.tree.card_count_for_node["a::b"] == 1
assert self.tree.card_count_for_node["a::c"] == 1
assert self.tree.card_count_for_node["b"] == 1
assert self.tree.card_count_for_node["b::c"] == 1
assert self.tree.card_count_for_node["b::c::d"] == 1
self.tree.delete_subtree("b::c")
card = self.database().card(card._id, is_id_internal=True)
assert card.tag_string() == ""
self.database().con.execute("select tags from cards where _id=?",
(card._id, )).fetchone()[0] == "b"
assert self.tree.card_count_for_node["__ALL__"] == 5
assert self.tree.card_count_for_node["a"] == 3
assert self.tree.card_count_for_node["Z"] == 1
assert self.tree.card_count_for_node["a::b"] == 1
assert self.tree.card_count_for_node["a::c"] == 1
assert "b" not in self.tree.card_count_for_node
assert "__UNTAGGED__" in self.tree.card_count_for_node
assert "b::c" not in self.tree.card_count_for_node
assert "b::c::d" not in self.tree.card_count_for_node
def test_1(self):
fact_data = {"f": "question", "b": "answer"}
card_type = self.card_type_with_id("1")
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=[])[0]
self.controller().save_file()
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
assert len(list(self.tree.keys())) == 2
assert self.tree['__ALL__'] == ['__UNTAGGED__']
def test_rename_to_empty_2(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question4", "b": "answer4"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["A::tag1"])[0]
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
self.tree.rename_node("A", "")
assert self.tree.card_count_for_node["tag1"] == 1
assert len(self.database().tags()) == 2
def test_4(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question4", "b": "answer4"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["a::b"])[0]
fact_data = {"f": "question", "b": "answer"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["a"])[0]
fact_data = {"f": "question2", "b": "answer2"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["Z"])[0]
fact_data = {"f": "question3", "b": "answer3"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["a::c"])[0]
fact_data = {"f": "question5", "b": "answer5"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["b::c::d"])[0]
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
assert self.tree.card_count_for_node["__ALL__"] == 5
assert self.tree.card_count_for_node["a"] == 3
assert self.tree.card_count_for_node["Z"] == 1
assert self.tree.card_count_for_node["a::b"] == 1
assert self.tree.card_count_for_node["a::c"] == 1
assert self.tree.card_count_for_node["b"] == 1
assert self.tree.card_count_for_node["b::c"] == 1
assert self.tree.card_count_for_node["b::c::d"] == 1
self.tree.rename_node("Z", "Z::Z")
self.tree.rename_node("b::c", "b::cc")
assert self.tree.card_count_for_node["__ALL__"] == 5
assert self.tree.card_count_for_node["a"] == 3
assert self.tree.card_count_for_node["Z"] == 1
assert self.tree.card_count_for_node["Z::Z"] == 1
assert self.tree.card_count_for_node["a::b"] == 1
assert self.tree.card_count_for_node["a::c"] == 1
assert self.tree.card_count_for_node["b"] == 1
assert self.tree.card_count_for_node["b::cc"] == 1
assert self.tree.card_count_for_node["b::cc::d"] == 1
def test_rename_to_forbidden(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question4", "b": "answer4"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["A::tag1"])[0]
fact_data = {"f": "question", "b": "answer"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["A"])[0]
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
self.tree.rename_node("A", "__UNTAGGED__")
assert "__UNTAGGED__" in self.tree.card_count_for_node
def test_count_1(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question4", "b": "answer4"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["b"])[0]
fact_data = {"f": "question", "b": "answer"}
card = self.controller().create_new_cards(fact_data,
card_type,
grade=-1,
tag_names=["b", "b"])[0]
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
assert self.tree.card_count_for_node["__ALL__"] == 2
def test_rename_to_existing_tag_2(self):
card_type = self.card_type_with_id("1")
fact_data = {"f": "question4", "b": "answer4"}
card = self.controller().create_new_cards(
fact_data,
card_type,
grade=-1,
tag_names=["Xx::vb::test", "Xx::aa::vb::test"])[0]
from mnemosyne.libmnemosyne.tag_tree import TagTree
self.tree = TagTree(self.mnemosyne.component_manager)
assert len(self.database().tags()) == 3
self.tree.rename_node("Xx::aa::vb::test", "Xx::vb::test")
assert self.tree.card_count_for_node["Xx::vb::test"] == 1
assert "Xx::aa::vb::test" not in self.tree.card_count_for_node
assert "," not in self.database().con.execute(\
"select tags from cards where _id=?", (card._id,)).fetchone()[0]
assert self.database().con.execute(\
"select count() from tags_for_card").fetchone()[0] == 1
assert len(self.database().tags()) == 2
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
