def __getitem__(self, deckname):
if deckname not in self:
deck_id = random.randrange(1 << 30, 1 << 31)
self[deckname] = genanki.Deck(deck_id, deckname)
return super(DeckCollection, self).__getitem__(deckname)
def __init__(self, name):
rand_id = random.randrange(1 << 30, 1 << 31)
self.id = rand_id
self.name = name
self.deck = genanki.Deck(rand_id, name)
def generateDeck(filename):
deck_id = abs(hash(filename)) % (10**7)
if filename.endswith('.txt'):
filename = filename[:-4]
return genanki.Deck(deck_id, filename)
import genanki
import csv
hanzi_deck = genanki.Deck(2079969689, "Hanzi")
radical_model = genanki.Model(2024474028,
'Radical',
fields=[
{
"name": "sort"
},
{
"name": "Radical"
},
{
"name": "Traditional"
},
{
"name": "Pinyin"
},
{
"name": "Meaning"
},
],
templates=[
{
'name':
'Card 1',
'qfmt':
'{{Radical}}',
'afmt':
from pathlib import Path
import genanki
import markdown2
# Custom note class to allow for card answer modification while keeping the same id
# The guid is only computed from the card title field
# This allows to update a deck without Anki thinking it is a brand new one
class MyNote(genanki.Note):
@property
def guid(self):
return genanki.guid_for(self.fields[0])
my_anki_deck = genanki.Deck(2059400110, "TIL")
my_model = genanki.Model(
1607392319,
"Simple Model",
fields=[
{
"name": "Question"
},
{
"name": "Answer"
},
],
templates=[
{
"name": "Card 1",
"qfmt": "{{Question}}",
fields=[
{'name': 'Question'},
{'name': 'Question_PL'},
{'name': 'Answer'},
{'name': 'Answer_PL'},
],
templates=[
{
'name': 'Card 1',
'qfmt': '{{Question}}<br>-<br>{{Question_PL}}',
'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}<br>-<br>{{Answer_PL}}',
},
])
genanki_deck_istqb = genanki.Deck(
4400040005,
'ISTQB FL')
for i in glossary:
field1 = i['term_eng']
field2 = i['term_pl']
field3 = i['desc_eng']
field4 = i['desc_pl']
my_note = genanki.Note(
model=genanki_model_istqb,
fields=[field1, field2, field3, field4])
genanki_deck_istqb.add_note(my_note)
genanki.Package(genanki_deck_istqb).write_to_file('istqb_glossary.apkg')
model_id,
'Simple Model',
fields=[
{'name': 'Question'},
{'name': 'Answer'},
],
templates=[
{
'name': 'Card 1',
'qfmt': '{{Question}}',
'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
my_deck = genanki.Deck(
deck_id,
'Marseilles'
)
episodes = []
num_episodes = 1
class Row:
def __init__(self, begin, end, text):
self.begin = begin
self.end = end
self.text = text
def transpose_xmltree(tree):
rows = [] # use a list since we'll be traversing anyway
for child in tree.iter():
if 'begin' in child.attrib:
border-top: 1px solid #555;
border-bottom: 1px solid #555;
font-size: 12px;
padding: 1px;
text-align: left;
}
.entry-definition {
font-size: 10px;
}
.entry-other-kanji {
font-size 10px;
border: none;
}
''')
deck = genanki.Deck(1901981190, '教育漢字')
for grade in grades:
for kanji in grade:
example_word = ''
if len(kanji.words) > 0:
example_word = kanji.words[0].word
example_entry = '<table>'
for word in kanji.words:
example_entry += '<tr>'
example_entry += '<td><span style="white-space:nowrap;">%s</span></td>' % word.reading
example_entry += '<td class="entry-definition">%s</td>' % '<br>'.join(
word.senses)
example_entry += '</tr>'
example_entry += '</table><br>'
def play(token: str, output_filename: str):
notion_client = GermanBankNotionClient(token)
bank_nouns = sorted([noun for noun in notion_client.get_bank_nouns()])
bank_verbs = sorted([verb for verb in notion_client.get_bank_verbs()])
# bank_nouns = sorted(BANK_NOUNS)
# bank_verbs = sorted(BANK_VERBS)
nouns = [noun.german_word_singular for noun in bank_nouns]
verbs = [verb.german_word for verb in bank_verbs]
entries = Dropdown.get_palette_entries()
entries.update(ScrollingListBox.get_palette_entries())
palette = Palette("default", **entries)
screen = urwid.raw_display.Screen()
screen.set_terminal_properties(256)
subject = TestDropdown(
items=nouns,
# label="nouns",
scrollbar=True,
auto_complete=True,
left_chars=' ',
right_chars=' ',
)
verb = TestDropdown(
items=verbs,
# label="verbs",
scrollbar=True,
auto_complete=True,
left_chars=' ',
right_chars=' ',
)
object_ = TestDropdown(
items=nouns,
# label="nouns",
scrollbar=True,
auto_complete=True,
left_chars=' ',
right_chars=' ',
)
boxes = [subject, verb, object_]
boxes_grid = urwid.Columns(boxes)
blank_it = {
"blanked": "verb"
} # Lazy hack to make this accessible within sub method
def add_sentence_to_deck(basic_sentence: BasicSentence, blank_it: str, _):
deck.add_note(basic_sentence.to_anki_note(blank_it))
def generate_all_sentences_as_buttons() -> typing.List[urwid.Button]:
return [
urwid.Button(
label=
f"{basic_sentence.get_question_sentence(blank_it['blanked'])} | {basic_sentence.get_answer_sentence()}",
on_press=functools.partial(add_sentence_to_deck,
basic_sentence,
blank_it['blanked']),
) for basic_sentence in generate_all_sentences()
]
def generate_all_sentences() -> typing.List[BasicSentence]:
subject2 = bank_nouns[subject.selected_value].random_noun().first()
verb2 = bank_verbs[verb.selected_value]
object2 = bank_nouns[object_.selected_value].random_noun().first()
res = []
while True:
basic_sentence = BasicSentence(subject2, verb2, object2)
res.append(basic_sentence)
try:
try:
subject2 = subject2.rotate()
except StopIteration:
subject2 = subject2.first()
object2 = object2.rotate()
except StopIteration:
break
return res
deck = genanki.Deck(
deck_id=1878326705, # Hard-coded value selected by me
name="German::Grammar",
)
sentence_list = urwid.Pile(generate_all_sentences_as_buttons())
def refresh_all_sentences(_, __):
sentence_list.widget_list = generate_all_sentences_as_buttons()
urwid.connect_signal(subject.pop_up, "select", refresh_all_sentences)
urwid.connect_signal(verb.pop_up, "select", refresh_all_sentences)
urwid.connect_signal(object_.pop_up, "select", refresh_all_sentences)
pile = urwid.Pile([boxes_grid, sentence_list])
main = urwid.Frame(urwid.Filler(pile, valign=urwid.widget.TOP))
def global_input(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
elif key == 'R':
for box in boxes:
box.select_value(random.randint(0, len(box.values) - 1))
refresh_all_sentences(None, None)
elif key == 'r':
try:
focused_box = main.get_focus_widgets()[-2]
except IndexError:
pass
if focused_box in boxes:
focused_box.select_value(
random.randint(0,
len(focused_box.values) - 1))
refresh_all_sentences(None, None)
elif key in ('b', 'B'):
try:
focused_box = main.get_focus_widgets()[-2]
except IndexError:
pass
else:
if focused_box == subject:
blank_it["blanked"] = "subject"
elif focused_box == verb:
blank_it["blanked"] = "verb"
elif focused_box == object_:
blank_it["blanked"] = "object"
refresh_all_sentences(None, None)
else:
return False
loop = urwid.MainLoop(
main,
palette,
screen=screen,
unhandled_input=global_input,
pop_ups=True,
)
loop.run()
if deck.notes:
genanki.Package([deck]).write_to_file(output_filename)
print(
f"Complete! Added {len(deck.notes)} cards. Now import play.apkg to Anki, fix any changes, and sync Anki to AnkiCloud."
)
def generateDeck():
result_dict = []
with open('./data/source_examples.csv', encoding='UTF8') as csvfile:
reader = csv.reader(csvfile, delimiter='\t')
for row in reader:
template_dict = dict.fromkeys([
'Hanzi', 'Pinyin', 'Pinyin RAW', 'English', 'Kanji Number',
'Alternatives', 'Sound', 'Ancient Character', 'Examples'
])
for i, key in enumerate(template_dict.keys()):
template_dict[key] = row[i]
result_dict.append(template_dict)
print(result_dict[0])
my_model = genanki.Model(
1087741751,
'Chinese (Radicals)',
fields=[
{
'name': 'Hanzi'
},
{
'name': 'Pinyin'
},
{
'name': 'English'
},
{
'name': 'Kanji Number'
},
{
'name': 'Alternatives'
},
{
'name': 'Sound'
},
{
'name': 'Ancient Character'
},
{
'name': 'Examples'
},
],
templates=[
{
'name':
'Recall',
'qfmt':
"\n".join([
"<div class=container>",
"<div class=radical_number>Radical Number: {{Kanji Number}}</div>",
"<div class=tags>{{Deck}} {{#Tags}} -- {{/Tags}}{{Tags}}</div>",
"</div>",
"<div class=chinese> {{Hanzi}}</div>",
"{{#Alternatives}}<div class=note>Alternatives: <div class=chinese>{{Alternatives}}</div></div>{{/Alternatives}}",
]),
'afmt':
"\n".join([
"{{FrontSide}}",
"<hr>",
"<div>{{English}}</div>",
"<br>",
"<div class=reading>{{Pinyin}}</div>",
"<div class=note>Examples:{{Examples}}</div>",
"{{#Ancient Character}}<div class=note>Ancient Character:</div>{{Ancient Character}}{{/Ancient Character}}",
"<br>",
"{{Sound}}",
]),
},
],
css="\n".join([
".card {",
"font-family: arial;",
"font-size: 20px;",
"text-align: center;",
"color: black;",
"background-color: white;",
"word-wrap: break-word;",
"}",
"img {",
"border: 1px solid #ddd;",
"border-radius: 4px;",
"padding: 5px;",
"width: 150px;",
"}",
".win .chinese { font-family: \"MS Mincho\", \"ＭＳ 明朝\"; }",
".mac .chinese { }",
".linux .chinese { font-family: \"Kochi Mincho\", \"東風明朝\"; }",
".mobile .chinese { font-family: \"Hiragino Mincho ProN\"; }",
".chinese { font-size: 30px;}",
".reading { font-size: 20px;}",
".comment {font-size: 15px; color:grey;}",
".tags {color:gray;text-align:right;font-size:10pt;}",
".radical_number {color:gray;text-align:left;font-size:10pt;}",
".note {color:gray;font-size:12pt;margin-top:20pt;}",
".hint {font-size:12pt;}",
"",
".tone1 {color: red;}",
".tone2 {color: orange;}",
".tone3 {color: green;}",
".tone4 {color: blue;}",
".tone5 {color: gray;}",
"",
".container {",
" display: grid;",
" grid-gap: 1rem;",
" grid-template-columns: grid-template-columns: repeat(2, 1fr);",
" grid-template-areas:\"a b\"",
"}",
]))
my_deck = genanki.Deck(1540858611, 'Chinese Radicals Deck+')
for item in result_dict:
my_note = genanki.Note(model=my_model,
fields=[
item['Hanzi'], item['Pinyin'],
item['English'], item['Kanji Number'],
item['Alternatives'], item['Sound'],
item['Ancient Character'], item['Examples']
])
my_deck.add_note(copy.deepcopy(my_note))
my_package = genanki.Package(my_deck)
media_img_files = ["./media/img/" + i for i in os.listdir("./media/img")]
media_audio_files = [
"./media/audio/" + i for i in os.listdir("./media/audio")
]
my_package.media_files = media_img_files + media_audio_files
my_package.write_to_file('./decks/Chinese-Radicals-Deck-Plus.apkg')
'<p class="style-meaning">{{Meaning}}</p>'
'<p class="style-reading">{{Reading}}</p>'
'<p class="style-others">Onyomi: {{Onyomi}}</p>'
'<p class="style-others">Kunyomi: {{Kunyomi}}</p>'
'<p class="style-others">Nanori: {{Nanori}}</p>',
},
],
css=".card { font-family: Noto Sans CJK JP Regular; text-align:center; font-size: 100px; color: #ffffff; background: #f100a1; margin: 45px auto; }"
".style-front { font-family: Noto Sans CJK JP Regular; text-align:center; font-size: 100px; color: #ffffff; background: #f100a1; margin: 50px auto; }"
".style-meaning { font-family: Noto Sans CJK JP Regular; text-align:center; font-size: 60px; color: #ffffff; background: #f100a1; margin: 0px; }"
".style-level { font-size: 10px; font-weight: bold; position: absolute; top: 0; right: 0; margin: 15px; }"
".style-reading { font-family: Noto Sans CJK JP Regular; text-align:center; font-size: 60px; color: #ffffff; background: #f100a1; margin-top: 15px; margin-bottom: 25px; } "
".style-others { font-family: Noto Sans CJK JP Regular; font-size: 30px; color: #ffffff; text-align: center; margin: 0px; padding: 0px; } "
".line-dash { margin: 50px; border-top: #ffffff dashed 2px; }")
wanianki_kanji = genanki.Deck(wanianki_kanji_id, 'WaniAnki Kanji')
kanji_character = []
kanji_onyomi = []
kanji_kunyomi = []
kanji_nanori = []
kanji_reading = []
kanji_level = []
kid = 1
with open('wanikani_kanji.json') as kanji:
font = ImageFont.truetype("KanjiStrokeOrders_v4.001.ttf", 150)
k = json.load(kanji)
sortlevel = [x for x in k['requested_information'] if 'level' in x]
kanji_by_level = sorted(sortlevel, key=lambda x: x['level'])
import genanki as ga
import os
# Unique ID's
math_vector_deck_id = 5103388589
math_vector_model_id = 2052455201
# Deck structure
math_vector_deck = ga.Deck(
math_vector_deck_id,
'Math Vectors - PyGen')
math_vector_package = ga.Package(math_vector_deck)
# Model structure
math_vector_model = ga.Model(
math_vector_model_id,
'PyGen Image Card',
fields=[
{'name': 'Question'},
{'name': 'Answer'},
],
templates=[
{
'name': 'Image Card',
'qfmt': '{{Question}}',
'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}',
},
])
def create_card_from_images(image_front, image_back):
templates=[
{
"name": "From to Learning",
"qfmt": f2l_front_template,
"afmt": f2l_back_template,
},
{
"name": "Learning to From",
"qfmt": l2f_front_template,
"afmt": l2f_back_template,
},
],
css=styling,
)
my_deck = genanki.Deck(DECK_ID, "Duolingo Words")
media_files = []
for word_id, word in words.items():
# Basic fields
word_definition = word["word_definition"]
fields = [
str(JAPANESE_SKILLS.index(word["skill"])),
word_definition["translations"],
word_definition["word"],
word_definition["pronunciation"],
f"[sound:{word_definition['tts_filename']}]",
]
media_files.append(word_definition["tts_local"])
def __getitem__(self, deckname):
if deckname not in self:
deck_id = simple_hash(deckname)
self[deckname] = genanki.Deck(deck_id, deckname)
return super(DeckCollection, self).__getitem__(deckname)
import re
# Extracts verb phrases
import textacy
# set up Anki elements
# lang_names = {'en': 'English'}
name = "mydeck"
arr = ["first", "second", "third"]
string = "firstSen, secondSen, thridSen"
word = ''
definition = ""
with open('cats0.txt', mode='r', encoding='utf-8', errors='ignore') as file:
content = file.read()
deck = genanki.Deck(2059406710, name)
model = genanki.Model(
1607392319,
'Word',
fields=[{
'name': 'Word'
}, {
'name': 'Definition'
}, {
'name': 'Examples'
}],
templates=[{
'name':
'Card 1',
'qfmt':
'{{Word}}',
from argparse import ArgumentParser
from collections import OrderedDict
from toml.decoder import TomlDecoder
from toml.encoder import TomlEncoder
from update_frequencies import ANIME_FREQUENCY_SUBFIELD
from update_frequencies import FREQUENCY_FIELD
from update_frequencies import calculate_highest_frequency
OUTPUT_FILENAME = 'kanji_card_deck_output.apkg'
# use random.randrange(1 << 30, 1 << 31) to generate a suitable model_id,
# and hardcode it into your Model definition.
KANJI_CARD_DECK = genanki.Deck(
2000001234, # XXX: DO NOT CHANGE
'Generated Japanese') # XXX: DO NOT CHANGE
KANJI_CARD_MODEL = genanki.Model(
2000001235, # XXX: DO NOT CHANGE
'Generated Japanese Model', # The name of the model can change.
fields=[
# NB: Make changes to the Anki deck model fields using the
# Anki interface first, or imports won't work as expected.
# Even additive changes MUST be made in Anki's UI first, or
# you wind up with a new deck 'Generated Japanese Model-{hash}'
{
'name': 'Kanji'
},
{
'name': 'Kana'
}, {
'name': 'Example sentence'
}, {
'name': 'Source'
}],
templates=[
{
'name': 'Card 1',
'qfmt': front_template,
'afmt': back_template,
},
],
css=style_template)
# Deck
my_deck = genanki.Deck(1547962859, 'English🇺🇸::Kindle')
if __name__ == "__main__":
notes = [[
'expr_test1', 'no_ipa', 'no_audio', 'no_def', 'no_image',
'no_collocation', 'no_example', 'no_source'
],
[
'expr_test2', 'no_ipa', 'no_audio', 'no_def', 'no_image',
'no_collocation', 'no_example', 'no_source'
],
[
'expr_test3', 'no_ipa', 'no_audio', 'no_def', 'no_image',
'no_collocation', 'no_example', 'no_source'
]]