def DeckGen(name, file_path, shuffle_card, word_notes, kanji_notes): my_deck = genanki.Deck(random.randrange(1 << 30, 1 << 31), name) if shuffle_card: def shuffle_dict(dictionary): tmp = list(dictionary.items()) random.shuffle(tmp) return dict(tmp) word_notes = shuffle_dict(word_notes) kanji_notes = shuffle_dict(kanji_notes) notes = [] for word_note in word_notes: for c in word_note: if c in kanji_notes: notes.append(kanji_notes.pop(c)) notes.append(word_notes[word_note]) # Remaining kanji for kanji_note in kanji_notes: notes.insert(random.randrange(0, len(notes)), kanji_notes[kanji_note]) counter = 0 for note in notes: note.fields[0] = str(counter) counter = counter + 1 my_deck.add_note(note) if len(notes) > 0: genanki.Package(my_deck).write_to_file(file_path)
def __call__(self, **kwargs): db = kwargs[self.plugin_config["in"]] only_kanjis = kwargs[self.plugin_config["only"]] model = genanki.Model( 1607392319, "Simple Model", fields=[ { "name": "Question" }, { "name": "Answer" }, ], templates=[{ "name": "Card 1", "qfmt": "{{Question}}", "afmt": '{{FrontSide}}<hr id="answer">{{Answer}}', }], ) deck = genanki.Deck(int(self.plugin_config["deck_id"]), self.plugin_config["title"]) notes = [generate_note(_, db.get(_, None), model) for _ in only_kanjis] for _ in notes: deck.add_note(_) genanki.Package(deck).write_to_file(self.plugin_config["output"])
def write_to_file_anki(self, file_name: str): """ Write the anki file to a specific file :param file_name: The file name (Without `.apkg`) """ my_package = genanki.Package(self.deck) # Copy files from other paths into the current directory files_to_delete = set() for file in self.files: for remove_file_path in remove_file_paths: if remove_file_path in file: file_to_delete_later = file \ .replace(remove_file_path + '/', '') copyfile(file, file_to_delete_later) files_to_delete.add(file_to_delete_later) self.files.remove(file) self.files.add(file_to_delete_later) if debug: print("Package the following media files:", self.files) my_package.media_files = list(self.files) my_package.write_to_file(file_name + '.apkg') # Delete copied files if debug: print("files_to_delete", files_to_delete) for delete_file in files_to_delete: os.remove(delete_file)
def write_deck_to_file(path): basename = os.path.basename(path) name = os.path.splitext(basename)[0] deck_name = name.replace("_", " ").title() deck = genanki.Deck(hash(deck_name), deck_name) with open(path) as f: notes = yaml.load(f, Loader=yaml.FullLoader) seen = set() for note_data in notes: note_id = note_data["id"] note_cloze = note_data["cloze"] note_tags = note_data["tags"] if note_id in seen: sys.exit("duplicate id {} found".format(note_id)) if not cloze_note_regex.match(note_cloze): sys.exit( "note id {} with cloze '{}' doesn't match expected format". format(note_id, note_cloze)) print(note_data) note = genanki.Note(guid=genanki.guid_for(note_id), fields=[note_cloze], tags=note_tags, model=genanki.CLOZE_MODEL) deck.add_note(note) seen.add(note_id) genanki.Package(deck).write_to_file("{}.apkg".format(name))
def generate(self, freq): deck = genanki.Deck(random.randint(100000000, 200000000), self.name) for word in list(freq): w = self.cur.execute("SELECT * FROM stardict WHERE word = '%s'" % word).fetchone() if not w: continue idx = w[0] word = w[1] sw = w[2] phonetic = w[3] if w[3] else "" definition = w[4] if w[4] else "" translation = w[5] if w[5] else "" pos = w[6] collins = w[7] oxford = w[8] tag = w[9] bnc = w[10] frq = w[11] exchange = w[12] detail = w[13] audio = w[14] note = genanki.Note(model=self.model, fields=[ word, phonetic, self.write_html_p(translation), self.write_html_p(definition) ]) deck.add_note(note) genanki.Package(deck).write_to_file(self.name + '.apkg')
def main(): # read in the input json data (a flat array of objects) for our cards with open("resources/cards.sealang.json") as json_data: cards = json.load(json_data) # read in the mapping of card's source property to the anki collection # this allows for hierarchical categories in the generated deck with open("resources/source-map.json") as json_data: source_map = json.load(json_data) with open("resources/cards.css") as cssData: card_style = cssData.read() # defines how to use card's source property to look up the collection name in the source-map file # you'll probably need to rewrite this function for your specific data. def cardGroupFunction(card): prefix = card['source'].split("-")[0] return source_map[prefix]["source"] cardsBySource = itertools.groupby(cards, cardGroupFunction) decks = [] model = get_model(card_style) for source, cards in cardsBySource: if source == "SKIP": continue # :: has special meaning in Anki card names: it nests decks. deck_name = "Thai::" + source print("creating... " + deck_name) deck = new_deck(deck_name) for card in distinct(cards): card = new_card(model, card['thai'], card['english']) deck.add_note(card) decks.append(deck) genanki.Package(decks).write_to_file('dist/thai.apkg')
def run(self): deck = genanki.Deck(1596048154, "Tests DGT") pack = genanki.Package(deck) for question in Question.select(): note_question = f'<p>{question.text}</p><ul>' for answer in question.answers: note_question += f'<li><strong>{answer.letter})</strong> {answer.text}</li>' note_question += '</ul>' self.logger.info("Creating note: %s", note_question) note_answer = f'<p><strong>{question.correct_answer}</strong></p>' # Media files should have unique filenames. image_media_path = get_crawl_image_media_path(question.image) note_image = f'<img src="{os.path.basename(image_media_path)}"/>' pack.media_files.append(image_media_path) note = genanki.Note( model=test_model, fields=[ note_question, note_answer, note_image, ], ) deck.add_note(note) self.logger.info("Packing...") pack.write_to_file(f"{settings.DATA_PATH}/tests-dgt.apkg") self.logger.info("Done")
def create_deck(csv_path, language, deck_name, deck_id=None, model_id=None): language = language df = pandas.read_csv(csv_path, sep="\t") df.iloc[:, 0].apply(text_to_speech, language=language, path="data/audio") field_names = list(df) my_model = generate_model(model_name=language, field_names=field_names, identifier=model_id) my_deck = generate_deck(name=deck_name, identifier=deck_id) df.loc[:, "audiofile"] = df.iloc[:, 0].apply(text_to_filename, prefix=f"{language}_", suffix=".mp3") df.apply(lambda row: my_deck.add_note(generate_note(my_model, row.values)), axis=1) my_package = genanki.Package(my_deck) my_package.media_files = [ f"data/audio/{file}" for file in list(df.audiofile) ] package_path = f"{text_to_filename(deck_name)}.apkg" my_package.write_to_file(package_path) print(f'Generated deck "{deck_name}" in "{package_path}"')
def test_media_files_absolute_paths(self): # change to a scratch directory so we can write files os.chdir(tempfile.mkdtemp()) media_dir = tempfile.mkdtemp() deck = genanki.Deck(123456, 'foodeck') note = genanki.Note(TEST_MODEL, [ 'question [sound:present.mp3] [sound:missing.mp3]', 'answer <img src="present.jpg"> <img src="missing.jpg">' ]) deck.add_note(note) # populate files with data present_mp3_path = os.path.join(media_dir, 'present.mp3') present_jpg_path = os.path.join(media_dir, 'present.jpg') with open(present_mp3_path, 'wb') as h: h.write(VALID_MP3) with open(present_jpg_path, 'wb') as h: h.write(VALID_JPG) self.import_package( genanki.Package(deck, media_files=[present_mp3_path, present_jpg_path])) missing, unused, invalid = self.check_media() assert set(missing) == {'missing.mp3', 'missing.jpg'}
def make_anki_deck_from_srt_file(srt_file: Path, *, name: str, output_dir: Path) -> Path: srt_file = srt_file.absolute() deck = genanki.Deck(1, name) model = genanki.Model( 1, "Simple Model", fields=[ { "name": "Question" }, { "name": "Answer" }, ], templates=[{ "name": "Card 1", "qfmt": "{{Question}}", "afmt": "{{Answer}}", }], ) cards = make_cards_from_srt_file(srt_file) for card in cards: note = genanki.Note(model=model, fields=[card.front, card.back]) deck.add_note(note) output_path = (output_dir / f"{name}.apkg").absolute() genanki.Package(deck).write_to_file(output_path) return output_path
def write_to_file(self, fn): if len(fn) < 6 or fn[-5:] != '.apkg': fn += '.apkg' package = genanki.Package(self.deck) print("Adding media files: ", self.media_files) package.media_files = self.media_files package.write_to_file(fn)
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 go(deck_filename: str, url: str): """ Pull it all together and write the deck to a file. """ html = get_html(url) soup = get_soup(html) methods = get_methods(soup) deck = make_anki_deck(methods, deck_filename) genanki.Package(deck).write_to_file(deck_filename + '.apkg')
def create_anki_package(output, cards, deck_name): # Assign cards to an existing deck name, otherwise # generate a new id and persist this into the model # dictionary if deck_name in deck_id_list: pass else: # TODO: add a new dictionary value with a key pass deck_id = deck_id_list[deck_name] my_deck = genanki.Deck(deck_id, deck_name) model_id = model_ids[deck_name] model = anki_model(model_id) for word in cards: note = genanki.Note(sort_field=1, model=model, fields=[word.word, word.pinyin, word.definition]) my_deck.add_note(note) output_location = os.path.join(output, "testOutput.apkg") genanki.Package(my_deck).write_to_file(output_location)
def main(): '''Main function.''' parser = argparse.ArgumentParser() parser.add_argument('--regs', action='store_true') parser.add_argument('--prefs', action='store_true') parser.add_argument('--caps', action='store_true') parser.add_argument('--all', action='store_true') args = parser.parse_args() if args.regs: process_regions() if args.prefs: process_prefectures() if args.caps: process_capitals() if args.all: # To get the statistics and indices of the regions right we need # all the information from the prefectures first! This is written # to a JSON file only, use preprocess to stop the Anki output! process_prefectures(preprocess=True) process_regions() process_prefectures() # Fix the indices according to the regions process_capitals() genanki.Package(PREF_DECK).write_to_file('output.apkg')
def make_notes(self, rawNoteDict, deck_name, out_path, tag, include_sound=False): deck = genanki.Deck(2051337110, deck_name) self.printOrLog( "\nNote maker is now gathering enrichment data for the words, this may take a while, especially if you are including audio files. The scanner will update progress here every 25 words..." ) i = 0 media_paths = [] for simp in rawNoteDict: if self.thread_obj != None and self.thread_obj.interrupt_and_quit == True: break i += 1 if i % 25 == 0: self.printOrLog(f"{i} words enriched") note, media_path = self.enrich_word(rawNoteDict[simp], include_sound) media_paths.append(media_path) deck.add_note(genanki.Note(self.note_model, note, tags=[tag])) if self.thread_obj != None and self.thread_obj.interrupt_and_quit == True: return self.printOrLog("Note maker is making a package") apkg = genanki.Package(deck) if include_sound == True: apkg.media_files = media_paths apkg.write_to_file(out_path) self.printOrLog( f"Note maker wrote {len(rawNoteDict)} new notes to to {join(dirname(realpath(__file__)),out_path)}" )
def main(): '''Main function.''' parser = argparse.ArgumentParser() parser.add_argument('--regs', action='store_true') parser.add_argument('--states', action='store_true') # parser.add_argument('--caps', action='store_true') parser.add_argument('--all', action='store_true') args = parser.parse_args() if args.regs: process_regions() if args.states: process_states() # if args.caps: # process_capitals() if args.all: process_states(preprocess=True) process_regions() process_states() # process_capitals() genanki.Package(STATE_DECK).write_to_file('states_us.apkg')
def main(): # find courses for kurs in [f.path for f in os.scandir(".") if f.is_dir()]: decks = [] kursName = kurs[2:] if kursName.startswith("."): continue # find unit for einheit in [f.path for f in os.scandir(kurs) if f.is_dir()]: kursEinheit = einheit[len(kursName) + 3:] if kursEinheit.startswith("."): continue if kursEinheit.startswith("images"): generateGraphviz(kursName + "/images") continue # generate deck decks.append(generateDeck(kursName, kursEinheit)) # pack decks to one project anki = genanki.Package(decks) # add images to project if os.path.isdir(kursName + "/images"): anki.media_files = [ f.path for f in os.scandir(kursName + "/images") if f.is_file() ] try: anki.write_to_file(kursName + ".apkg") printSuccess("Deck {} successfully created.".format(kursName)) except IOError: printError("A problem occured while creating " "file: {}".format(kursName + ".apkg"))
def main(args): video = args.video sub = args.sub styles = args.styles apkg = args.apkg name = args.name offset = args.offset crop = args.crop video_path = Path(video) subs_path = Path(sub or video_path.with_suffix(".ass")) apkg_path = Path(apkg or video_path.with_suffix(".apkg")) name = name or str(video_path.with_suffix("").name) tmp_path = video_path.with_suffix("") if not tmp_path.is_dir(): tmp_path.mkdir() subs = pysubs2.load(subs_path) notes, media_files = create_notes(subs, video_path, tmp_path, styles, offset, crop) deck = genanki.Deck(deck_id=random.randrange(1 << 30, 1 << 31), name=name) for note in notes: deck.add_note(note) apkg = genanki.Package(deck) apkg.media_files = media_files apkg.write_to_file(apkg_path)
def create_deck(source, first: str, second: str, name: str, header: bool, output: str): """Creates a new anki deck from a csv file.""" if not os.path.exists(source): source = Path('../').resolve().joinpath(source) df: pd.DataFrame if header is False: df = pd.read_csv(source, header=None) else: df = pd.read_csv(source) if first.isnumeric(): first = int(first) if second.isnumeric(): second = int(second) output = Path(output).resolve() engine = DeckGenerator(model=simple_flashcard, df=df, word=first, answer=second) my_deck = engine.generate_cards().get_deck(name) if name is None: name = 'output' anki.Package(my_deck).write_to_file(f'{output}/{name}.apkg') click.echo(f'Done creating new deck {name} at {output}.')
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 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 generate_decks(token: str, output_filename: str) -> None: """ Scrapes the Notion table bank, and converts them into Anki decks ready for importing. """ decks = { BankCategory.VOCABULARY: genanki.Deck( deck_id=1854703173, # Hard-coded value selected by me name="German::Vocabulary", ), BankCategory.PHRASE: genanki.Deck( deck_id=1568577201, # Hard-coded value selected by me name="German::Phrases", ), } for german_bank_item in GermanBankNotionClient(token).load_bank_items(): if isinstance(german_bank_item, BankWord): deck = decks[BankCategory.VOCABULARY] elif isinstance(german_bank_item, Phrase): deck = decks[BankCategory.PHRASE] else: raise ValueError(f"Unexpected bank item {german_bank_item}") german_note = GermanNote.from_german_model(german_bank_item) deck.add_note(german_note) genanki.Package(decks.values()).write_to_file(output_filename) click.echo(f"Complete! Now import {output_filename} to Anki, fix any changes, and sync Anki to AnkiCloud.")
def main(): my_model = genanki.Model( 1607392328, 'RuHamTest', css=""" .card { font-family: arial; font-size: 20px; text-align: center; color: black; background-color: white; } ul { width: 90%; list-style-type:"A"; margin:auto; padding:0; position:relative; left:5%; } """, fields=[ { 'name': 'idx' }, { 'name': 'Question' }, { 'name': 'Choice1' }, { 'name': 'Choice2' }, { 'name': 'Choice3' }, { 'name': 'Choice4' }, { 'name': 'Answer' }, ], templates=[{ 'name': 'Card 1', 'qfmt': ''' <h2>Вопрос №{{idx}}</h2><br> {{Question}}<br> <ul type='a'> <li id="1">{{ Choice1 }}</li> <li id="2">{{ Choice2 }}</li> <li id="3">{{ Choice3 }}</li> <li id="4">{{ Choice4 }}</li> </ul> ''', 'afmt': '{{FrontSide}}<script> document.getElementById("{{Answer}}").style.backgroundColor = "green"</script> ', }]) my_deck = genanki.Deck(2059400143, 'Ham Test RU') for idx, q, c1, c2, c3, c4, a in w_list(): my_note = genanki.Note(model=my_model, fields=[idx, q, c1, c2, c3, c4, a], sort_field='idx') my_deck.add_note(my_note) genanki.Package(my_deck).write_to_file('/output/hamtest.apkg')
def generate_flashcards(book: Book, words: List[Word], with_audio: bool) -> None: my_deck = genanki.Deck(2059400110, 'Vocabulary: ' + book.title) my_package = genanki.Package(my_deck) if with_audio: my_package.media_files = [word.audio for word in words if word.audio] templates = CardTemplates() for word in words: word_flashcards = generate_flashcards_from_word( word, templates, with_audio) for fs in word_flashcards: my_deck.add_note(fs) genanki.Package(my_deck).write_to_file('./Vocabulary_' + book.title + '.apkg')
def insert_cards_to_deck(cards, media_files): my_deck = genanki.Deck(2059400201311, 'japanese_vocab') my_package = genanki.Package(my_deck) my_package.media_files = media_files for card in cards: my_deck.add_note(card) my_package.write_to_file('output.apkg') print('Package output.apkg generated')
def read_file(self, file_name: str): with open(file_name) as f: lines = f.readlines() for line in lines: word, note = line.split(";") word = re.sub("\([^ ]*\)", "", word) self.add_word_to_deck(word, note) genanki.Package(dutch_deck).write_to_file("dutch_deck.apkg")
def _package(self) -> genanki.Package: deck = genanki.Deck(id(self._title), self._title) media = [] for card in self._cards: media += card.media() deck.add_note(card.export()) return genanki.Package(deck, media_files=media)
def test_model_with_sort_field_index(self): deck = genanki.Deck(332211, 'foodeck') note = genanki.Note(TEST_MODEL_WITH_SORT_FIELD_INDEX, ['a', '3.A']) deck.add_note(note) self.import_package(genanki.Package(deck)) anki_note = self.col.getNote(self.col.findNotes('')[0]) assert anki_note.model()['sortf'] == CUSTOM_SORT_FIELD_INDEX
def save_anki_package(self, buckets, export_file_name): for bucket in buckets: self.__add_bucket_to_deck(bucket) pack = genanki.Package(self.my_deck) pack.media_files = self.list_of_media_files Helper.create_folder_if_not_exist(os.path.dirname(export_file_name)) pack.write_to_file(export_file_name) print("ANKI deck saved to", export_file_name)