Add initial Anki deck generation from Obsidian vault

Author: lorey

README.md

@@ -3,6 +3,7 @@ This is my command-line tool for markdown-based knowledge bases called `obsi`.
 I use with my markdown-based [Obsidian](https://obsidian.md) notes.
 
 ## Features
+- generation of Anki Decks from your Obsidian Vault
 - index generation for tags: create pages that list all usages of a specific tag
 - tag recommendations (based on other tags) with machine learning
 - generation of calendar-related notes: daily, weekly, and monthly notes with respective links

cli.py

@@ -1,13 +1,18 @@
+"""
+obsi command line interface.
+"""
+
 import logging
 from collections import defaultdict
 from datetime import datetime, timedelta
 from pathlib import Path
 
 import click
 
+from obsi.anki import generate_anki_deck
 from obsi.markdown import create_day, create_index, create_note_list, create_week
 from obsi.ml import generate_tag_recommendations
-from obsi.storage import day_date_to_path, day_date_to_week_path, gen_notes
+from obsi.storage import Vault, day_date_to_path, day_date_to_week_path
 
 DAY_GENERATION_PADDING = 100
 WEEK_GENERATION_PADDING = 52
@@ -28,6 +33,14 @@ def run():
     update_indexes()
 
 
+@cli.command()
+def anki_deck():
+    name = f"Obsi notes for {NOTES_PATH}"
+    vault = Vault(NOTES_PATH)
+    notes = list(vault.generate_notes())
+    generate_anki_deck(name, notes, out_file="out/deck.apkg")
+
+
 def update_days(padding=DAY_GENERATION_PADDING):
     """
     Generates all days for the given padding.
@@ -65,7 +78,7 @@ def update_weeks(padding=WEEK_GENERATION_PADDING):
 
 
 def update_recommendations():
-    notes = list(gen_notes(NOTES_PATH))
+    notes = list(get_vault().generate_notes())
     for tag, notes_rec in generate_tag_recommendations(notes):
         content = create_note_list(tag, notes_rec)
         with open("out/recommendations-" + tag.lower().replace("#", ""), "w") as file:
@@ -84,7 +97,7 @@ def update_indexes():
 def generate_indexes(untagged_index=True):
     notes_per_tag = defaultdict(set)
     notes_untagged = []
-    for note in gen_notes(NOTES_PATH):
+    for note in get_vault().generate_notes():
         for tag in note.tags:
             notes_per_tag[tag].add(note)
 
@@ -103,6 +116,10 @@ def generate_indexes(untagged_index=True):
         yield "index-untagged", create_index("untagged notes", notes_untagged)
 
 
+def get_vault():
+    return Vault(NOTES_PATH)
+
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
     cli()

obsi/__init__.py

@@ -1,2 +1,6 @@
+"""
+obsi package.
+"""
+
 DAY_FORMAT = "%Y-%m-%d"
 MONTH_FORMAT = "%Y-%m"

obsi/anki.py

@@ -0,0 +1,63 @@
+"""
+module to generate Anki decks from notes.
+"""
+import html
+import logging
+
+import genanki
+
+
+class FileBasedNote(genanki.Note):
+    """
+    Anki note based on a Vault file.
+    """
+
+    def __init__(self, path, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # use the path as the unique identifier
+        # ensures that cards that keep their path get updated in place
+        self._guid = genanki.guid_for(path)
+
+
+def generate_anki_deck(name, notes, out_file="output.apkg"):
+    """
+    Generate an anki deck .apkg file from the given notes.
+
+    :param name: name of the deck
+    :param notes: notes to use for generation
+    :param out_file: path of resulting file
+    """
+    # generate the deck
+    anki_deck = genanki.Deck(2059400110, html.escape(name))
+
+    # set a model
+    anki_model = genanki.Model(
+        1607392319,
+        "File-based Card",
+        fields=[
+            {"name": "Path"},
+            {"name": "ObsidianUri"},
+        ],
+        templates=[
+            {
+                "name": "Card 1",
+                "qfmt": "What do you know about {{Path}}",
+                "afmt": '{{FrontSide}}<hr id="answer"><a href="{{ObsidianUri}}">open note</a>',
+            }
+        ],
+    )
+
+    for note in notes:
+        anki_node = FileBasedNote(
+            path=note,
+            model=anki_model,
+            fields=[
+                html.escape(str(note.get_relative_path())),
+                html.escape(note.get_obsidian_uri()),
+            ],
+        )
+        anki_deck.add_note(anki_node)
+
+    genanki.Package(anki_deck).write_to_file(out_file)
+    logging.info(f".apkg written to {out_file=}")

obsi/storage.py

@@ -1,49 +1,71 @@
 import re
+import typing
 from pathlib import Path
+from urllib.parse import urlencode
 
 from obsi import DAY_FORMAT
 from obsi.util import week_identifier_from_date
 
 
+class Vault:
+    """
+    An obsidian vault.
+    """
+    path = None
+
+    def __init__(self, path: typing.Union[Path, str]):
+        self.path = path if type(path) == Path else Path(path)
+        assert self.path.is_dir(), f"{self.path} is not a dir"
+
+    def generate_notes(self):
+        """Generate all notes in vault"""
+        for file_path in self.path.rglob("*.md"):
+            rel_path = file_path.relative_to(self.path)
+            yield Note.from_path(self, rel_path)
+
+    def __repr__(self):
+        return f"Vault({self.path=})"
+
+
 class Note:
+    """
+    A markdown-based note.
+    """
     @classmethod
-    def from_path(cls, path):
-        content = path_to_content(path)
-        return Note(path, content)
-
-    def __init__(self, path, content):
+    def from_path(cls, vault: Vault, path: Path):
+        path_abs = vault.path.joinpath(path)
+        assert path_abs.is_file(), f"no file found at {path_abs}"
+        content = path_to_content(path_abs)
+        return Note(vault, path, content)
+
+    def __init__(self, vault: Vault, path: Path, content: str):
+        self._vault = vault
         self._path = path
-        self.content = content
+        self._content = content
 
     def get_tags(self):
-        results = re.findall(r"#[A-z0-9]+", self.content)
+        results = re.findall(r"#[A-z0-9]+", self._content)
         return set(results)
 
-    def get_path(self):
+    def get_absolute_path(self):
+        return self._vault.path.joinpath(self._path)
+
+    def get_relative_path(self):
         return self._path
 
+    def get_obsidian_uri(self):
+        return "obsidian://open?" + urlencode({"vault": "notes", "file": self._path})
+
     def get_title(self):
         # todo md title
         # todo frontmatter title
         return self._path.name.replace(".md", "")
 
     tags = property(get_tags)
-    path = property(get_path)
     title = property(get_title)
 
     def __repr__(self):
-        return f"Note({self.path=})"
-
-
-def gen_notes(path):
-    """Generate all notes in a directory."""
-    home_path = Path(path)
-
-    # check that path exists
-    assert home_path.is_dir()
-
-    for file_path in home_path.rglob("*.md"):
-        yield Note.from_path(file_path)
+        return f"Note({self._vault=}, {self._path=})"
 
 
 def path_to_content(path):

requirements.in

@@ -11,4 +11,5 @@ pytest-cov
 click
 jinja2
 pandas
-scikit-learn
+scikit-learn
+genanki