def _update_pre_and_post_exists(self, lemma_dict: LemmaDict):
pre_lemma = self._register.get_lemma_by_sort_key(
Lemma.make_sort_key(lemma_dict["previous"]))
post_lemma = self._register.get_lemma_by_sort_key(
Lemma.make_sort_key(lemma_dict["next"]))
if pre_lemma and post_lemma:
pre_idx = self._register.get_index_of_lemma(pre_lemma)
post_idx = self._register.get_index_of_lemma(post_lemma)
else:
return
if pre_idx and post_idx:
if post_idx - pre_idx == 1:
self._register.lemmas.insert(
post_idx,
Lemma(lemma_dict, self._register.volume,
self._register.authors))
elif post_idx - pre_idx == 2:
self._register.lemmas[pre_idx + 1] = Lemma(
lemma_dict, self._register.volume, self._register.authors)
else:
raise RegisterException(
f"The update of the register {self._register.volume.name} "
f"with the dict {lemma_dict} is not possible. "
f"Diff between previous and next aren't 1 or 2")
self._try_update_next_and_previous(lemma_dict,
self._register[pre_idx + 1])
def test_from_dict_errors(self):
for entry in ["lemma"]:
test_dict = copy.deepcopy(self.basic_dict)
del test_dict[entry]
with self.assertRaises(RegisterException):
Lemma(test_dict, Volumes()["I,1"], self.authors)
for entry in ["previous", "next", "redirect", "chapters"]:
test_dict = copy.deepcopy(self.basic_dict)
del test_dict[entry]
self.assertIsNone(
Lemma(test_dict,
Volumes()["I,1"], self.authors)[entry])
re_register_lemma = Lemma(self.basic_dict,
Volumes()["I,1"], self.authors)
compare("lemma", re_register_lemma["lemma"])
compare("previous", re_register_lemma["previous"])
compare("next", re_register_lemma["next"])
compare(True, re_register_lemma["redirect"])
compare([{
"start": 1,
"end": 1,
"author": "Herman Abel"
}, {
"start": 1,
"end": 2,
"author": "William Abbott"
}], re_register_lemma["chapters"])
compare(5, len(re_register_lemma))
def update_lemma(self,
lemma_dict: LemmaDict,
remove_items: UpdaterRemoveList,
self_supplement: bool = False) -> str:
sort_key = VolumeRegister.normalize_sort_key(lemma_dict)
if "lemma" in lemma_dict and self._register.get_lemma_by_name(
lemma_dict["lemma"], self_supplement):
self._update_lemma_by_name(lemma_dict, remove_items,
self_supplement)
return "update_lemma_by_name"
if self._register.get_lemma_by_sort_key(sort_key):
self._update_by_sortkey(lemma_dict, remove_items)
return "update_by_sortkey"
if "previous" in lemma_dict and "next" in lemma_dict \
and self._register.get_lemma_by_sort_key(Lemma.make_sort_key(lemma_dict["previous"])) \
and self._register.get_lemma_by_sort_key(Lemma.make_sort_key(lemma_dict["next"])):
self._update_pre_and_post_exists(lemma_dict)
return "update_pre_and_post_exists"
if "previous" in lemma_dict \
and self._register.get_lemma_by_sort_key(Lemma.make_sort_key(lemma_dict["previous"])):
self._update_pre_exists(lemma_dict)
return "update_pre_exists"
if "next" in lemma_dict \
and self._register.get_lemma_by_sort_key(Lemma.make_sort_key(lemma_dict["next"])):
self._update_post_exists(lemma_dict)
return "update_post_exists"
raise RegisterException(
f"The update of the register {self._register.volume.name} "
f"with the dict {lemma_dict} is not possible. "
f"No strategy available")
def test_sort_key_provide_by_lemma(self):
sort_dict = copy.deepcopy(self.basic_dict)
sort_dict["lemma"] = "Lemma"
sort_dict["sort_key"] = "WasAnderes"
sort_lemma = Lemma(sort_dict, self.volumes["I,1"], self.authors)
compare("uasanderes", sort_lemma.sort_key)
sort_dict["sort_key"] = "WasAnderes 02"
sort_lemma = Lemma(sort_dict, self.volumes["I,1"], self.authors)
compare("uasanderes 002", sort_lemma.sort_key)
def test_return_dict(self):
reverse_dict = {
"chapters": [{
"start": 1,
"author": "Abel",
"end": 1
}, {
"start": 1,
"end": 2,
"author": "Abbott"
}],
"wp_link":
"tada",
"proof_read":
2,
"ws_link":
"tadü",
"sort_key":
"something",
"redirect":
True,
"next":
"next",
"previous":
"previous",
"lemma":
"lemma"
}
dict_lemma = Lemma(reverse_dict, self.volumes["I,1"], self.authors)
chapter_dict_1 = OrderedDict(
(("start", 1), ("end", 1), ("author", "Abel")))
chapter_dict_2 = OrderedDict(
(("start", 1), ("end", 2), ("author", "Abbott")))
expected_dict = OrderedDict([
("lemma", "lemma"), ("previous", "previous"), ("next", "next"),
("sort_key", "something"), ("redirect", True), ("proof_read", 2),
("wp_link", "tada"), ("ws_link", "tadü"),
("chapters", [chapter_dict_1, chapter_dict_2])
])
compare(expected_dict, dict_lemma.lemma_dict)
missing_dict = copy.deepcopy(reverse_dict)
del missing_dict["next"]
del missing_dict["redirect"]
missing_dict["previous"] = None
missing_expected_dict = copy.deepcopy(expected_dict)
del missing_expected_dict["next"]
del missing_expected_dict["redirect"]
del missing_expected_dict["previous"]
missing_dict_lemma = Lemma(missing_dict, self.volumes["I,1"],
self.authors)
compare(missing_expected_dict, missing_dict_lemma.lemma_dict)
def _update_in_supplements_with_neighbour_creation(
self, lemma_to_update: Lemma, lemma_dict: LemmaDict,
remove_items: UpdaterRemoveList):
lemma_to_update.update_lemma_dict(lemma_dict, remove_items)
if lemma_to_update:
idx = self._register.get_index_of_lemma(lemma_to_update)
if idx:
if idx > 0:
self._u_i_s_w_n_c_1(idx, lemma_dict, lemma_to_update)
with contextlib.suppress(IndexError):
idx = self._register.get_index_of_lemma(lemma_to_update)
if idx:
self._u_i_s_w_n_c_2(idx, lemma_dict, lemma_to_update)
def test_squash_lemmas(self):
register = AlphabeticRegister("a", "be", None, "zzzzzz", OrderedDict())
lemma1 = Lemma({"lemma": "lemma", "chapters": [{"start": 1, "end": 1, "author": "Abel"}]},
Volumes()["I,1"],
self.authors)
lemma2 = Lemma({"lemma": "lemma", "chapters": [{"start": 1, "end": 1, "author": "Abel"}]},
Volumes()["III,1"],
self.authors)
lemma3 = Lemma({"lemma": "lemma2", "chapters": [{"start": 1, "end": 1, "author": "Abel"}]},
Volumes()["III,1"],
self.authors)
lemmas = [lemma1, lemma2, lemma3]
expection = [[lemma1, lemma2], [lemma3]]
compare(expection, register.squash_lemmas(lemmas))
def test_get_row_no_chapter(self):
one_line_dict = {
"lemma": "lemma",
"previous": "previous",
"next": "next",
"redirect": False,
"chapters": []
}
re_register_lemma = Lemma(one_line_dict, self.volumes["I,1"],
self.authors)
expected_row = """|-
||
||
|style="background:#AA0000"|UNK"""
compare(expected_row, re_register_lemma.get_table_row())
def _u_i_s_w_n_c_2(self, idx: int, lemma_dict: LemmaDict,
lemma_to_update: Lemma):
if self._register[idx + 1].sort_key == Lemma.make_sort_key(lemma_dict["next"]) \
or Lemma.make_sort_key(str(self._register[idx + 1]["lemma"])) \
== Lemma.make_sort_key(lemma_dict["next"]):
self._try_update_next(lemma_dict, lemma_to_update)
else:
self._register[idx + 1].update_lemma_dict({}, ["previous"])
if not self._register.get_lemma_by_sort_key(lemma_dict["next"]):
self._register.lemmas.insert(
idx + 1,
Lemma(
{
"lemma": lemma_dict["next"],
"previous": lemma_dict["lemma"]
}, self._register.volume, self._register.authors))
def _update_pre_exists(self, lemma_dict: LemmaDict):
pre_lemma = self._register.get_lemma_by_sort_key(
Lemma.make_sort_key(lemma_dict["previous"]))
if pre_lemma:
pre_idx = self._register.get_index_of_lemma(pre_lemma)
else:
return
# remove previous and next for gap
if pre_idx:
with contextlib.suppress(IndexError):
self._register[pre_idx + 1].update_lemma_dict({}, ["previous"])
with contextlib.suppress(KeyError):
del lemma_dict["next"]
# insert lemma
self._register.lemmas.insert(
pre_idx + 1,
Lemma(lemma_dict, self._register.volume,
self._register.authors))
self._try_update_previous(lemma_dict, self._register[pre_idx + 1])
def _parse_short_description(source_text: str) -> Dict[str, str]:
new_lookup_dict: Dict[str, str] = {}
# splitting up by line and processing only the relevant lines from the table
for line in source_text.strip().splitlines()[4::2]:
# first group is the lemma, second is the description
match = re.search(r"\[\[RE:([^\]]*?)\]\]\|\|(.*)", line)
# don't process if there is an invalid description
if match:
if match.group(2) not in ["", "(-)"]:
new_lookup_dict[Lemma.make_sort_key(match.group(1))] = match.group(2)
return new_lookup_dict
def __init__(self, volume: Volume, authors: Authors):
super().__init__()
self._authors = authors
self._volume = volume
self.repo = DataRepo()
with open(
self.repo.get_data_path().joinpath(f"{volume.file_name}.json"),
"r",
encoding="utf-8") as json_file:
lemma_list = json.load(json_file)
for lemma in lemma_list:
self._lemmas.append(Lemma(lemma, self._volume, self._authors))
def _u_i_s_w_n_c_1(self, idx: int, lemma_dict: LemmaDict,
lemma_to_update: Lemma):
existing_pre_sortkey: str = self._register[idx - 1].sort_key
processed_pre_sortkey = Lemma.make_sort_key(
str(self._register[idx - 1]["lemma"]))
if "previous" in lemma_dict:
fetched_pre_sortkey = Lemma.make_sort_key(lemma_dict["previous"])
if fetched_pre_sortkey in (existing_pre_sortkey,
processed_pre_sortkey):
self._try_update_previous(lemma_dict, lemma_to_update)
else:
self._register[idx - 1].update_lemma_dict({}, ["next"])
if not self._register.get_lemma_by_sort_key(
lemma_dict["previous"]):
self._register.lemmas.insert(
idx,
Lemma(
{
"lemma": lemma_dict["previous"],
"next": lemma_dict["lemma"]
}, self._register.volume, self._register.authors))
def get_lemma_by_sort_key(
self,
sort_key: str,
self_supplement: bool = False) -> Optional[Lemma]:
# normalize it
sort_key = Lemma.make_sort_key(sort_key)
found_before = False
for lemma in self.lemmas:
if lemma.sort_key == sort_key:
if found_before or not self_supplement:
return lemma
found_before = True
return None
def try_update_previous_next_of_surrounding_lemmas(self,
lemma_dict: LemmaDict,
lemma_to_update: Lemma):
idx = self._register.get_index_of_lemma(lemma_to_update)
if idx is None:
return
previous_test = False
pre_lemma = None
if lemma_to_update["previous"]:
if idx - 1 >= 0:
# there is a lemma to update
pre_lemma = self._register[idx - 1]
else:
# no lemma to update, we are done here
return
with contextlib.suppress(KeyError, TypeError):
previous_test = \
Lemma.make_sort_key(str(lemma_to_update["previous"])) == \
Lemma.make_sort_key(str(pre_lemma["lemma"])) == \
Lemma.make_sort_key(lemma_dict["previous"])
if not previous_test:
raise RegisterException(
f"Current Lemma previous: \"{lemma_to_update['previous']}\" "
f"!= previous lemma name \"{pre_lemma['lemma'] if pre_lemma else pre_lemma}\" "
f"!= new lemma value previous \"{lemma_dict.get('previous', 'no key')}\""
)
next_test = False
next_lemma = None
if lemma_to_update["next"]:
try:
# there is a next lemma to update
next_lemma = self._register[idx + 1]
except IndexError:
# there is no next lemma we are done here
return
with contextlib.suppress(KeyError, TypeError):
next_test = \
Lemma.make_sort_key(str(lemma_to_update["next"])) == \
Lemma.make_sort_key(str(next_lemma["lemma"])) == \
Lemma.make_sort_key(lemma_dict["next"])
if not next_test:
raise RegisterException(
f"Current Lemma next: \"{lemma_to_update['next']}\" "
f"!= next lemma name \"{next_lemma['lemma'] if next_lemma else next_lemma}\" "
f"!= new lemma value next \"{lemma_dict.get('next', 'no key')}\""
)
if previous_test:
if pre_lemma:
pre_lemma.update_lemma_dict({"next": lemma_dict["lemma"]})
else:
raise RegisterException(
"Here went something wrong, pre_lemma is None.")
if next_test:
if next_lemma:
next_lemma.update_lemma_dict({"previous": lemma_dict["lemma"]})
else:
raise RegisterException(
"Here went something wrong, next_lemma is None.")
def task(self):
article = self.re_page.first_article
if article["VERWEIS"].value:
article["KURZTEXT"].value = ""
self.re_page.remove_error_category(category=self.MAINTENANCE_CAT)
return
if article["KURZTEXT"].value:
return
try:
article["KURZTEXT"].value = \
self.short_description_lookup[Lemma.make_sort_key(self.re_page.lemma_without_prefix)]
self.re_page.add_error_category(category=self.MAINTENANCE_CAT)
except KeyError:
pass
def test_wiki_links_bug_multipart_lemma(self):
re_register_lemma = Lemma(self.basic_dict, self.volumes["I,1"],
self.authors)
compare(("", ""), re_register_lemma.get_wiki_links())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["ws_link"] = "s:it:Autore:Lemma"
altered_dict["wp_link"] = "w:it:Autore:Lemma"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare(("[[w:it:Autore:Lemma|Lemma<sup>(WP it)</sup>]]<br/>"
"[[s:it:Autore:Lemma|Lemma<sup>(WS it)</sup>]]",
"data-sort-value=\"w:it:autore:lemma\""),
re_register_lemma.get_wiki_links())
def test_set_lemma_dict(self):
update_basic_dict = copy.deepcopy(self.basic_dict)
update_lemma = Lemma(update_basic_dict, self.volumes["I,1"],
self.authors)
update_dict = {
"lemma":
"lemma2",
"previous":
"previous1",
"next":
"next",
"chapters": [{
"start": 1,
"end": 3,
"author": "Abel"
}, {
"start": 3,
"end": 3,
"author": "Abbott"
}]
}
remove_item = ["redirect", "some_bla"]
update_lemma.update_lemma_dict(update_dict)
compare("lemma2", update_lemma["lemma"])
compare("lemma002", update_lemma.sort_key)
compare("previous1", update_lemma["previous"])
compare("next", update_lemma["next"])
self.assertTrue(update_lemma["redirect"])
compare([{
"start": 1,
"end": 3,
"author": "Abel"
}, {
"start": 3,
"end": 3,
"author": "Abbott"
}], update_lemma.lemma_dict["chapters"])
update_lemma.update_lemma_dict(update_dict, remove_items=remove_item)
compare("lemma2", update_lemma["lemma"])
compare("previous1", update_lemma["previous"])
compare("next", update_lemma["next"])
self.assertIsNone(update_lemma["redirect"])
compare([{
"start": 1,
"end": 3,
"author": "Abel"
}, {
"start": 3,
"end": 3,
"author": "Abbott"
}], update_lemma.lemma_dict["chapters"])
def _try_update_next(self, new_lemma_dict: LemmaDict,
lemma_to_update: Lemma):
if "next" in new_lemma_dict:
idx = self._register.get_index_of_lemma(lemma_to_update)
if idx:
with contextlib.suppress(IndexError):
next_lemma = self._register[idx + 1]
next_lemma_dict: LemmaDict = {
"lemma": new_lemma_dict["next"],
"previous": new_lemma_dict["lemma"]
}
next_next_lemma: Optional[str] = str(
next_lemma["next"]) if next_lemma["next"] else None
if next_next_lemma:
next_lemma_dict["next"] = next_next_lemma
if Lemma.make_sort_key(str(
next_lemma_dict["lemma"])) == next_lemma.sort_key:
next_lemma.update_lemma_dict(next_lemma_dict)
with contextlib.suppress(RegisterException):
self.try_update_previous_next_of_surrounding_lemmas(
next_lemma_dict, next_lemma)
def _try_update_previous(self, new_lemma_dict: LemmaDict,
lemma_to_update: Lemma):
if "previous" in new_lemma_dict:
idx = self._register.get_index_of_lemma(lemma_to_update)
if idx:
if idx - 1 < 0:
return
pre_lemma = self._register[idx - 1]
pre_lemma_dict: LemmaDict = {
"lemma": new_lemma_dict["previous"],
"next": new_lemma_dict["lemma"]
}
pre_pre_lemma: Optional[str] = str(
pre_lemma["previous"]) if pre_lemma["previous"] else None
if pre_pre_lemma:
pre_lemma_dict["previous"] = pre_pre_lemma
if Lemma.make_sort_key(
pre_lemma_dict["lemma"]) == pre_lemma.sort_key:
pre_lemma.update_lemma_dict(pre_lemma_dict)
with contextlib.suppress(RegisterException):
self.try_update_previous_next_of_surrounding_lemmas(
pre_lemma_dict, pre_lemma)
def test_get_lemma_status(self):
# basics
small_dict = {"lemma": "lemma"}
lemma = Lemma(small_dict, Volumes()["I,1"], self.authors)
compare(("UNK", "#AA0000"), lemma.status)
small_dict = {"lemma": "lemma", "proof_read": 1}
lemma = Lemma(small_dict, Volumes()["I,1"], self.authors)
compare(("UNK", "#AA0000"), lemma.status)
small_dict = {"lemma": "lemma", "proof_read": 2}
lemma = Lemma(small_dict, Volumes()["I,1"], self.authors)
compare(("KOR", "#556B2F"), lemma.status)
small_dict = {"lemma": "lemma", "proof_read": 3}
lemma = Lemma(small_dict, Volumes()["I,1"], self.authors)
compare(("FER", "#669966"), lemma.status)
# author (not) public domain
small_dict = {
"lemma": "lemma",
"chapters": [{
"start": 1,
"author": "Abel"
}]
}
lemma = Lemma(small_dict, Volumes()["I,1"], self.authors)
compare(("2069", "#FFCBCB"), lemma.status)
small_dict = {
"lemma": "lemma",
"proof_read": 3,
"no_creative_height": True,
"chapters": [{
"start": 1,
"author": "Abel"
}]
}
lemma = Lemma(small_dict, Volumes()["I,1"], self.authors)
compare(("FER", "#669966"), lemma.status)
def test_get_author(self):
re_register_lemma = Lemma(self.basic_dict, self.volumes["I,1"],
self.authors)
compare(
"Abert",
re_register_lemma._get_author_str(
LemmaChapter({
"start": 1,
"end": 2,
"author": "Abert"
})))
# check use case one chapter several authors
compare(
"Abert, Herman Abel",
re_register_lemma._get_author_str(
LemmaChapter({
"start": 1,
"end": 2,
"author": "redirect_list"
})))
# check if author not there
compare(
"Tada",
re_register_lemma._get_author_str(
LemmaChapter({
"start": 1,
"end": 2,
"author": "Tada"
})))
compare(
"",
re_register_lemma._get_author_str(
LemmaChapter({
"start": 1,
"end": 2
})))
def test_sort_key(self, testlist):
for item in testlist:
compare(item[1], Lemma.make_sort_key(item[0]))
def test_wiki_links(self):
re_register_lemma = Lemma(self.basic_dict, self.volumes["I,1"],
self.authors)
compare(("", ""), re_register_lemma.get_wiki_links())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["wp_link"] = "w:de:Lemma"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare(("[[w:de:Lemma|Lemma<sup>(WP de)</sup>]]",
"data-sort-value=\"w:de:lemma\""),
re_register_lemma.get_wiki_links())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["ws_link"] = "s:de:Lemma"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare(("[[s:de:Lemma|Lemma<sup>(WS de)</sup>]]",
"data-sort-value=\"s:de:lemma\""),
re_register_lemma.get_wiki_links())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["wd_link"] = "d:Q123456"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare(("[[d:Q123456|WD-Item]]", "data-sort-value=\"d:Q123456\""),
re_register_lemma.get_wiki_links())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["wp_link"] = "w:de:Lemma"
altered_dict["ws_link"] = "s:de:Lemma"
altered_dict["wd_link"] = "d:Q123456"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare(("[[w:de:Lemma|Lemma<sup>(WP de)</sup>]]<br/>"
"[[s:de:Lemma|Lemma<sup>(WS de)</sup>]]<br/>"
"[[d:Q123456|WD-Item]]", "data-sort-value=\"w:de:lemma\""),
re_register_lemma.get_wiki_links())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["wp_link"] = "w:de:Lemma = Irgendwas"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare((
"[[w:de:Lemma = Irgendwas|Lemma {{=}} Irgendwas<sup>(WP de)</sup>]]",
"data-sort-value=\"w:de:lemma = irgenduas\""),
re_register_lemma.get_wiki_links())
def test_get_row(self):
one_line_dict = {
"lemma": "lemma",
"previous": "previous",
"next": "next",
"short_description": "Blub",
"wp_link": "w:en:Lemma",
"ws_link": "s:de:Lemma",
"redirect": False,
"chapters": [{
"start": 1,
"end": 1,
"author": "Abel"
}]
}
re_register_lemma = Lemma(one_line_dict, self.volumes["I,1"],
self.authors)
expected_row = """|-
|[https://elexikon.ch/meyers/RE/I,1_1.png 1]
|Herman Abel
|style="background:#FFCBCB"|2069"""
compare(expected_row, re_register_lemma.get_table_row())
two_line_dict = {
"lemma":
"lemma",
"previous":
"previous",
"next":
"next",
"short_description":
"Blub",
"wp_link":
"w:en:Lemm",
"ws_link":
"s:de:Lemma",
"redirect":
False,
"chapters": [{
"start": 1,
"end": 1,
"author": "Abel"
}, {
"start": 1,
"end": 4,
"author": "Abbott"
}]
}
re_register_lemma = Lemma(two_line_dict, self.volumes["I,1"],
self.authors)
expected_row = """|-
|[https://elexikon.ch/meyers/RE/I,1_1.png 1]
|Herman Abel
|rowspan=2 style="background:#FFCBCB"|2100
|-
|[https://elexikon.ch/meyers/RE/I,1_1.png 1]-4
|William Abbott"""
compare(expected_row, re_register_lemma.get_table_row())
expected_row = """|-
|rowspan=2|I,1
|[https://elexikon.ch/meyers/RE/I,1_1.png 1]
|Herman Abel
|rowspan=2 style="background:#FFCBCB"|2100
|-
|[https://elexikon.ch/meyers/RE/I,1_1.png 1]-4
|William Abbott"""
compare(expected_row,
re_register_lemma.get_table_row(print_volume=True))
def test_is_valid(self):
no_chapter_dict = {"lemma": "lemma", "chapters": []}
Lemma(no_chapter_dict, self.volumes["I,1"], self.authors)
no_chapter_dict = {"lemma": "lemma", "chapters": [{"end": 1}]}
with self.assertRaises(RegisterException):
print(Lemma(no_chapter_dict, self.volumes["I,1"], self.authors))
def test_get_link(self):
re_register_lemma = Lemma(self.basic_dict, self.volumes["I,1"],
self.authors)
compare("[[RE:lemma|''{{Anker2|lemma}}'']]",
re_register_lemma.get_link())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["redirect"] = False
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare("[[RE:lemma|'''{{Anker2|lemma}}''']]",
re_register_lemma.get_link())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["redirect"] = "Some other Lemma"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare(
"[[RE:lemma|''{{Anker2|lemma}}'']] → '''[[RE:Some other Lemma|Some other Lemma]]'''",
re_register_lemma.get_link())
altered_dict = copy.deepcopy(self.basic_dict)
altered_dict["lemma"] = "Ist = gleich"
re_register_lemma = Lemma(altered_dict, self.volumes["I,1"],
self.authors)
compare("[[RE:Ist = gleich|''{{Anker2|Ist {{=}} gleich}}'']]",
re_register_lemma.get_link())
def _check_link(self, link_to_check: str):
if Lemma.make_sort_key(
link_to_check)[0].lower() in self._start_characters:
if not pywikibot.Page(self.wiki, f"RE:{link_to_check}").exists():
self.data.append(
(link_to_check, self.re_page.lemma_without_prefix))
def test_strip_accents(self):
compare("Αβαλας λιμηνaoueeeec",
Lemma._strip_accents("Ἀβάλας λιμήνäöüèéêëç"))
def normalize_sort_key(lemma_dict: LemmaDict) -> str:
if "sort_key" in lemma_dict:
return Lemma.make_sort_key(lemma_dict["sort_key"])
return Lemma.make_sort_key(lemma_dict["lemma"])
