def __init__(self, config_filename):
with open(config_filename, 'r') as f:
self._config = json.load(f)
self._tts = ZeusTTS(self._config["tts"])
self._model = {}
self._model["default"] = genanki.Model(
2004387350,
'zeus model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
"<div style='font-size: 30px;text-align: center;'>{{Question}}</div>",
'afmt':
"<div style='font-size: 30px;text-align: center;'>{{FrontSide}}<hr id='answer'>{{Answer}}</div>",
},
])
self._model["tts"] = genanki.Model(
1939171148,
'zeus tts model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
{
'name': 'MyMedia'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
"<div style='font-size: 30px;text-align: center;'>{{Question}}<br>{{MyMedia}}</div>",
'afmt':
"<div style='font-size: 30px;text-align: center;'>{{FrontSide}}<hr id='answer'>{{Answer}}</div>",
},
])
def __generate_model(self):
if self.with_forvo_link:
forvo_section = "<hr id='sound'><h3>Произношение:</h3>" \
+ "<a href=\"https://forvo.com/search/{{word}}/en/\">FORVO</a>"
return genanki.Model(
self.model_id,
self.model_name,
fields=[
{
"name": "word"
},
{
"name": "translate"
},
{
"name": "extended"
},
{
"name": "collocations"
},
],
templates=[
{
"name":
"{{word}}",
"qfmt":
"<h1>{{word}}</h1>",
"afmt":
"{{FrontSide}}<hr id='answer'><h3>Перевод:</h3>{{translate}}"
+ "<hr id='extended'><h3>Примеры:</h3>{{extended}}" +
"<hr id='collocations'><h3>Словосочетания:</h3>{{collocations}}"
+ (forvo_section if self.with_forvo_link else "")
},
])
def get_model(css):
return genanki.Model(
1487859596,
'thai_model',
fields=[
{
'name': 'th'
},
{
'name': 'en'
},
],
templates=[
{
'name':
'th → en',
'qfmt':
'<div id="thai">{{th}}</div>',
'afmt':
'{{FrontSide}}<hr id="answer"><div id="english">{{en}}</div>',
},
{
'name': 'en → th',
'qfmt': '<div id="english">{{en}}</div>',
'afmt':
'{{FrontSide}}<hr id="answer"><div id="thai">{{th}}</div>',
},
],
css=css)
def create_deck(self):
deck = genanki.Deck(2059400110, self.name_entry.get())
fields = []
for f in self.columns.keys(): # for each field
fields.append({'name': f})
model = genanki.Model(
1607392319,
'Word',
fields=fields,
templates=[{
'name':
'Card 1',
'qfmt':
'{{Question}}',
'afmt':
'<b>{{FrontSide}}</b>: {{Answer}}<hr id="usage">{{Usage}}'
}])
for w in self.parent.words:
fields = []
for f in self.columns.keys(): # for each field
if f == 'Question':
fields.append(w)
else:
fields.append(self.parent.words[w][f])
note = genanki.Note(model=model, fields=fields)
deck.add_note(note)
genanki.Package(deck).write_to_file(self.file_entry.get())
def test_num_fields_equals_model_ok():
m = genanki.Model(1894808898,
'Test Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
{
'name': 'Extra'
},
],
templates=[
{
'name': 'Card 1',
'qfmt': '{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
n = genanki.Note(
model=m,
fields=[
'What is the capital of Taiwan?', 'Taipei',
'Taipei was originally inhabitied by the Ketagalan people prior to the arrival of Han settlers in 1709.'
])
n.write_to_db(mock.MagicMock(), mock.MagicMock(), mock.MagicMock(),
mock.MagicMock())
def test_suppress_warnings(recwarn):
my_model = genanki.Model(1376484377,
'Simple Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
my_note = genanki.Note(model=my_model,
fields=['Capital of <$> Argentina', 'Buenos Aires'])
with pytest.warns(None) as warn_recorder:
warnings.filterwarnings(
'ignore',
message='^Field contained the following invalid HTML tags',
module='genanki')
my_note.write_to_db(mock.MagicMock(), mock.MagicMock(),
mock.MagicMock(), mock.MagicMock())
assert not warn_recorder
def test_num_fields_less_than_model_raises():
m = genanki.Model(1894808898,
'Test Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
{
'name': 'Extra'
},
],
templates=[
{
'name': 'Card 1',
'qfmt': '{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
n = genanki.Note(model=m,
fields=['What is the capital of Taiwan?', 'Taipei'])
with pytest.raises(ValueError):
n.write_to_db(mock.MagicMock(), mock.MagicMock(), mock.MagicMock(),
mock.MagicMock())
def create_fill_in_the_blank_cards(dictionary, article_text, text_filename):
global article_deck
definition_model = genanki.Model(
1607392320,
'Simple Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[{
'name': 'Card 1',
'qfmt': '{{Question}}',
'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}',
}])
for word in dictionary:
if dictionary[word] != 'rejected!' and dictionary[
word] != 'alt word form used.':
sentences_with_word = get_words_sentence_from_text(
dictionary[word][1], article_text, False)
for sentence in sentences_with_word:
my_note = genanki.Note(
model=definition_model,
tags=[text_filename],
fields=[
sentence + ' (' + str(round(time.time())) + ')',
dictionary[word][1]
])
article_deck.add_note(my_note)
def _genanki_setup(self):
bh_model = genanki.Model(
1468421455, # keep static, generated with random.randrange(1 << 30, 1 << 31) as per genanki docs
'BH Model',
fields=[
{
'name': 'Autokennzeichen'
},
{
'name': 'Name'
},
],
templates=[{
'name': 'Kennzeichen -> Name',
'qfmt': '<h3>{{Autokennzeichen}}</h3>',
'afmt': '<h4>{{Name}}</h4>',
}, {
'name': 'Name -> Kennzeichen',
'qfmt': '<h4>{{Name}}</h4>',
'afmt': '<h3>{{Autokennzeichen}}</h3>',
}])
self.bh_model = bh_model
bh_deck = genanki.Deck(1468421456, 'BHs in .at')
self.bh_deck = bh_deck
def __init__(self, deck_name):
self.list_of_media_files = []
self.model_id = Helper.get_random_id()
self.deck_id = Helper.get_random_id()
self.model_name = "[email protected] export"
fields = [
{'name': 'Word'},
{'name': 'Image'},
{'name': 'Sound'},
{'name': 'Sound_Meaning'},
{'name': 'Sound_Example'},
{'name': 'Meaning'},
{'name': 'Example'},
{'name': 'IPA'},
{'name': 'Word_Translation'},
{'name': 'Meaning_Translation'},
{'name': 'Example_Translation'},
]
templates = [
{
'name': 'Card 1',
'qfmt': Helper.read_file_to_one_line("anki_templates\\front_template.txt"),
'afmt': Helper.read_file_to_one_line("anki_templates\\back_template.txt"),
},
{
'name': 'Card 2',
'qfmt': Helper.read_file_to_one_line("anki_templates\\front_template2.txt"),
'afmt': Helper.read_file_to_one_line("anki_templates\\back_template2.txt"),
},
]
css = Helper.read_file_to_one_line("anki_templates\\css_template.txt")
self.my_model = genanki.Model(self.model_id, self.model_name, fields=fields, templates=templates, css=css)
self.my_deck = genanki.Deck(self.deck_id, deck_name)
def get_model(self):
return genanki.Model(
self.model_id,
"Dutch Word",
css=css,
fields=[
{
"name": "Word"
},
{
"name": "Part of speech"
},
{
"name": "Question"
},
{
"name": "Answer"
},
],
templates=[
{
"name": "Dutch card",
"qfmt": "{{Question}}",
"afmt": "{{Answer}}",
},
],
)
def _model(self) -> genanki.Model:
""" Wrapper for simple default model """
fields = [{
"name": "Verb"
}, {
"name": "Translation"
}, {
"name": "Question"
}, {
"name": "Answer"
}, {
"name": "Rule_Pattern"
}, {
"name": "Rule_Real"
}]
templates = [{
"name": "Card",
"qfmt": read(dirname(__file__) + "/front.html"),
"afmt": read(dirname(__file__) + "/back.html"),
}]
style = read(dirname(__file__) + "/style.min.css")
return genanki.Model(
20200324,
"Verbs",
fields=fields,
templates=templates,
css=style,
)
def get_model():
style = """
* {
font-size: 1.1rem;
}
h2 {
font-size: 1.5rem;
}
"""
model = genanki.Model(
1106024768,
'translated words model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name': 'Card 1',
'qfmt': '<h2>{{Question}}</h2>',
'afmt': '<h2>{{FrontSide}}</h2><hr id="answer">{{Answer}}',
},
],
css=style)
return model
def makeModel(anki_ID, css='font-size:x-large;'):
DSKY_model = genanki.Model(
anki_ID,
'Desert Sky',
fields=[
{
'name': 'English'
},
{
'name': 'MSA'
},
{
'name': 'MSA_transl'
},
{
'name': 'EGA'
},
{
'name': 'EGA_transl'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{English}}',
'afmt':
'{{FrontSide}}<hr id="answer">MSA: {{MSA}}, {{MSA_transl}} EGA: {{EGA}}, {{EGA_transl}}',
},
])
return (DSKY_model)
def create_model():
faces_model = genanki.Model(
1607392318,
'Faces Model',
fields=[
{
'name': 'Pic'
},
{
'name': 'Name'
},
{
'name': 'Description'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Pic}}',
'afmt':
'{{FrontSide}}<hr id=answer><b>{{Name}}</b><br><br>{{Description}}',
},
])
return faces_model
def __buildGenankiModel(self):
cssStr = ".card { text-align: center; font-size: 24px; }"
self.model = genanki.Model(
1607392219,
'Simple Model',
css=cssStr,
fields=[{
'name': 'Question'
}, {
'name': 'FrontAudio'
}, {
'name': 'Answer'
}, {
'name': 'BackAudio'
}],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Question}}<br>{{FrontAudio}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}<br>{{BackAudio}}',
},
])
def create_definitions_cards(dictionary, text_filename):
global article_deck
definition_model = genanki.Model(
1607392319,
'Simple Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[{
'name': 'Card 1',
'qfmt': '{{Question}}',
'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}',
}, {
'name': 'Card 2',
'qfmt': '{{Answer}}',
'afmt': '{{FrontSide}}<hr id="answer">{{Question}}',
}])
for word in dictionary:
if dictionary[word] != 'rejected!' and dictionary[
word] != 'alt word form used.':
my_note = genanki.Note(model=definition_model,
tags=[text_filename],
fields=[
word + ' (' + str(round(time.time())) +
')', dictionary[word][0]
])
article_deck.add_note(my_note)
def add_note_anki_deck(deck, q_text, a_text):
"""Adds a note to a genanki deck object.
Args:
deck (genanki Deck)
q_text (string)
a_text (string)
"""
# Basic anki note model
model_id = random.randrange(1 << 30, 1 << 31)
my_model = genanki.Model(model_id,
'Simple Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
my_note = genanki.Note(model=my_model, fields=[q_text, a_text])
deck.add_note(my_note)
print(f'Added note: q_text: {q_text}, a_text: {a_text}')
def test_num_fields_more_than_model_raises():
m = genanki.Model(1894808898,
'Test Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name': 'Card 1',
'qfmt': '{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
n = genanki.Note(
model=m,
fields=[
'What is the capital of Taiwan?', 'Taipei',
'Taipei was originally inhabitied by the Ketagalan people prior to the arrival of Han settlers in 1709.'
])
with pytest.raises(ValueError):
n.write_to_db(mock.MagicMock(), mock.MagicMock(), mock.MagicMock(),
itertools.count(int(time.time() * 1000)))
def add_img_note_anki_deck(deck, q_file, a_file):
"""adds an image note to a genanki Deck
Args:
deck (genanki Deck)
q_file (string): Path of question image
a_file (string): Path of answer image
"""
model_id = random.randrange(1 << 30, 1 << 31)
my_model = genanki.Model(
model_id,
'Simple Model with Media',
fields=[
{
'name': 'QuestionImage'
},
{
'name': 'AnswerImage'
},
],
templates=[
{
'name': 'Card 1',
'qfmt': '{{QuestionImage}}',
'afmt': '{{FrontSide}}<hr id="answer">{{AnswerImage}}',
},
])
my_note = genanki.Note(
model=my_model,
fields=[f"<img src={q_file.name}>", f"<img src={a_file.name}>"])
deck.add_note(my_note)
print(f'-Added note with q_img: {q_file.name}, a_img: {a_file.name}')
def test_warns_on_invalid_html_tags():
my_model = genanki.Model(1376484377,
'Simple Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
my_note = genanki.Note(model=my_model,
fields=['Capital of <$> Argentina', 'Buenos Aires'])
with pytest.warns(
UserWarning,
match='^Field contained the following invalid HTML tags.*$'):
my_note.write_to_db(mock.MagicMock(), mock.MagicMock(),
mock.MagicMock(), mock.MagicMock())
def get_card_model_2():
with open("style/front.html") as f:
front = f.read()
with open("style/back.html") as f:
back = f.read()
return genanki.Model(
1607392319,
'Simple Model',
fields=[
{'name': 'Word'},
{'name': 'Definition'},
{'name': 'Sentence'},
{'name': 'Synonym'},
{'name': 'Antonym'},
{'name': 'Part of Speech'},
{'name': 'Transcription'},
{'name': 'Source'},
{'name': 'Picture'},
{'name': 'Audio'}
],
templates=[
{
'name': 'Card 1',
'qfmt': front,
'afmt': back,
},
])
def test_ok():
my_model = genanki.Model(1376484377,
'Simple Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
my_note = genanki.Note(model=my_model,
fields=['Capital of Argentina', 'Buenos Aires'])
with pytest.warns(None) as warn_recorder:
my_note.write_to_db(mock.MagicMock(), mock.MagicMock(),
mock.MagicMock(), mock.MagicMock())
# Should be no warnings issued.
assert not warn_recorder
def as_anki_deck(self):
model = genanki.Model(
self.id,
"{} model".format(self.title),
fields=[
{
"name": "Question"
},
{
"name": "Answer"
},
],
templates=[
{
"name": "Card 1",
"qfmt": "{{Question}}",
"afmt": '{{FrontSide}}<hr id="answer">{{Answer}}',
},
],
)
anki_deck = genanki.Deck(self.id, self.title)
for card in self.cards:
note = genanki.Note(model=model,
fields=[card.front,
card.render_back()])
anki_deck.add_note(note)
return anki_deck
def create_deck(words, lang, deckfile):
name = "Kindle " + lang_names[lang] + " words"
deck = genanki.Deck(2059400110, name)
model = genanki.Model(
1607392319,
'Word',
fields=[{
'name': 'Question'
}, {
'name': 'Answer'
}, {
'name': 'Usage'
}],
templates=[{
'name':
'Card 1',
'qfmt':
'{{Question}}',
'afmt':
'<b>{{FrontSide}}</b>: {{Answer}}<hr id="usage">{{Usage}}'
}])
for w in words:
note = genanki.Note(
model=model, fields=[w, words[w]['definition'], words[w]['usage']])
deck.add_note(note)
genanki.Package(deck).write_to_file(deckfile)
def make_model(style):
m_id = 1395453623
m_name = 'md2anki simple v1'
if len(style) > 0:
m_id = random.randrange(1 << 30, 1 << 31)
m_name += ' (styled)'
return genanki.Model(
m_id,
m_name,
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'<article class="markdown-body">{{Question}}</article>',
'afmt':
'<article class="markdown-body">{{FrontSide}}</article><hr id="answer"><article class="markdown-body">{{Answer}}</article>',
},
],
css=style)
def getModel():
MODEL_NAME = "MODEL"
css = ".card {\
font-family: arial; \
font-size: 30px; \
text-align: center; \
color: black; \
background-color: white; \
}"
model = genanki.Model(
getID(MODEL_NAME),
MODEL_NAME,
fields=[
{"name": "Question"},
{"name": "Answer"}
],
templates=[
{
"name": "Card 1",
"qfmt": "<center>{{Question}}</center>",
"afmt": "<center>{{FrontSide}}<hr \
id=\"answer\">{{Answer}}</center>"
}
],
css=css
)
return model
def createKard(Name, Inhalt):
my_model = genanki.Model(
random.randrange(1 << 30, 1 << 31),
'PythonAutomatedCards',
fields=[
{'name': 'Definition'},
{'name': 'Answer'},
],
templates=[
{
'name': 'Card 1',
'qfmt': '{{Question}}',
'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
my_deck = genanki.Deck(random.randrange(1 << 30, 1 << 31), Name)
for i in Inhalt:
Header = i['Header']
Text = i['Text']
# print(Header + " --> " + Text)
my_note = genanki.Note(
model=my_model,
fields=[Header, Text]
)
my_deck.add_note(my_note)
print("Deck: " + Name + " -> " + str(len(Inhalt)) + " Karten erstellt")
genanki.Package(my_deck).write_to_file(Name + '.apkg')
pass
def gen_card(deck, front, back):
my_model = genanki.Model(1607392319,
'Simple Model',
fields=[
{
'name': 'Question'
},
{
'name': 'Answer'
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Question}}',
'afmt':
'{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
my_note = genanki.Note(model=my_model, fields=[front, back])
deck.add_note(my_note)
return deck
def load_chinese_note_model():
with open(FIELDS_FILE, encoding='utf-8') as fields, open(TEMPLATES_FILE, encoding='utf-8') as templates, \
open(CSS_FILE, encoding='utf-8') as css, open(SCRIPT_FILE, encoding='utf-8') as script:
templates_formatted = templates.read()
templates_formatted = templates_formatted.replace(
'CHARACTER',
'{{#Traditional}}<span class="nobr">{{Traditional}}</span>|{{/Traditional}}'
'<span class="nobr">{{Simplified}}</span>')
templates_formatted = templates_formatted.replace(
'PINYIN',
'{{#Taiwan Pinyin}}{{Taiwan Pinyin}} | {{/Taiwan Pinyin}}{{Pinyin}}'
)
script_contents = []
for i, line in enumerate(script.read().splitlines()):
if 'BEGIN TESTS' in line:
break
if i > 0:
line = ' ' + line
script_contents.append(line)
script_contents.append(' main();')
script_contents = '\n'.join(script_contents)
templates_formatted = templates_formatted.replace(
'SCRIPT', script_contents)
return genanki.Model(
CHINESE_NOTE_MODEL_ID,
'Chinese',
fields=fields.read(),
templates=templates_formatted,
css=css.read(),
)
