Feature/replace-get-highlighted-text

ankimorphs/__init__.py

@@ -18,6 +18,7 @@
 from typing import Literal
 
 import aqt
+from anki import hooks
 from anki.cards import Card
 from anki.collection import OpChangesAfterUndo
 from aqt import gui_hooks, mw
@@ -39,7 +40,7 @@
 from . import ankimorphs_globals as am_globals
 from . import (
     browser_utils,
-    debugging_utils,
+    debug_utils,
     message_box_utils,
     name_file_utils,
     reviewing_utils,
@@ -52,6 +53,7 @@
 from .extra_settings import ankimorphs_extra_settings, extra_settings_keys
 from .extra_settings.ankimorphs_extra_settings import AnkiMorphsExtraSettings
 from .generators.generators_window import GeneratorWindow
+from .highlight_morphs_jit import highlight_morphs_jit
 from .known_morphs_exporter import KnownMorphsExporterDialog
 from .progression.progression_window import ProgressionWindow
 from .recalc import recalc_main
@@ -97,6 +99,8 @@ def main() -> None:
 
     gui_hooks.profile_will_close.append(cleanup_profile_session)
 
+    hooks.field_filter.append(highlight_morphs_jit)
+
 
 def init_toolbar_items(links: list[str], toolbar: Toolbar) -> None:
     # Adds the 'L: I:' and 'Recalc' to the toolbar

ankimorphs/ankimorphs_config.py

@@ -816,6 +816,18 @@ def get_modify_enabled_filters() -> list[AnkiMorphsConfigFilter]:
     return modify_filters
 
 
+def get_matching_filter(note: Note) -> AnkiMorphsConfigFilter | None:
+    assert mw is not None
+    config_filters = AnkiMorphsConfig().get_config_filters()
+    assert isinstance(config_filters, list)
+
+    for am_filter in config_filters:
+        note_type_id: NotetypeId | None = mw.col.models.id_for_name(am_filter.note_type)
+        if note_type_id == note.mid:
+            return am_filter
+    return None
+
+
 def get_matching_modify_filter(note: Note) -> AnkiMorphsConfigFilter | None:
     assert mw is not None
     modify_filters: list[AnkiMorphsConfigFilter] = get_modify_enabled_filters()

ankimorphs/ankimorphs_globals.py

@@ -7,7 +7,7 @@
 # Semantic Versioning https://semver.org/
 __version__ = "3.3.0"
 
-DEV_MODE: bool = False
+DEV_MODE: bool = True
 
 PROFILE_SETTINGS_FILE_NAME = "ankimorphs_profile_settings.json"
 NAMES_TXT_FILE_NAME = "names.txt"

ankimorphs/debugging_utils.py → ankimorphs/debug_utils.py

@@ -6,6 +6,9 @@
 from pathlib import Path
 from typing import Any
 
+from . import ankimorphs_globals
+from .morpheme import Morpheme
+
 
 def print_stacktrace() -> None:
     stacktrace = ""
@@ -72,3 +75,14 @@ def print_directory_tree(root_dir: str, indent: str = "") -> None:
             print_directory_tree(item_path, indent + "    ")
         else:
             print(new_indent + item)
+
+
+def dev_print(message: str) -> None:
+    if ankimorphs_globals.DEV_MODE:
+        print(message)
+
+
+def dev_print_morphs(morphs: list[Morpheme]) -> None:
+    if ankimorphs_globals.DEV_MODE:
+        for morph in morphs:
+            print(f"morph: {morph.inflection}")

ankimorphs/highlight_morphs_jit.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import re
+
+import anki
+from anki.template import TemplateRenderContext
+
+from . import (
+    ankimorphs_config,
+    ankimorphs_globals,
+    debug_utils,
+    text_highlighting,
+    text_preprocessing,
+)
+from .ankimorphs_config import AnkiMorphsConfig, AnkiMorphsConfigFilter
+from .ankimorphs_db import AnkiMorphsDB
+from .morpheme import Morpheme
+from .morphemizers import morphemizer as morphemizer_module
+from .morphemizers import spacy_wrapper
+from .morphemizers.morphemizer import Morphemizer, SpacyMorphemizer
+
+
+def highlight_morphs_jit(
+    field_text: str,
+    field_name: str,
+    filter_name: str,
+    context: TemplateRenderContext,
+) -> str:
+    """Use morph learning progress to decorate the morphemes in the supplied text.
+    Adds css classes to the output that can be styled in the card."""
+
+    # Perf: Bail early if the user attempts to use this template filter on the already
+    # formatted data.
+    if (
+        filter_name
+        not in [
+            "am-highlight",
+            "am-highlight-furigana",
+            "am-highlight-kanji",
+            "am-highlight-kana",
+        ]
+        or field_name == ankimorphs_globals.EXTRA_FIELD_HIGHLIGHTED
+    ):
+        return field_text
+
+    am_config_filter: AnkiMorphsConfigFilter | None = (
+        ankimorphs_config.get_matching_filter(context.note())
+    )
+
+    if am_config_filter is None:
+        return field_text
+
+    morphemizer: Morphemizer | None = morphemizer_module.get_morphemizer_by_description(
+        am_config_filter.morphemizer_description
+    )
+
+    if not morphemizer:
+        return field_text
+
+    am_config = AnkiMorphsConfig()
+
+    card_morphs: list[Morpheme] = _get_morph_meta_for_text(
+        morphemizer, field_text, am_config
+    )
+
+    if not card_morphs:
+        return field_text
+
+    debug_utils.dev_print(f"filter name: {filter_name}")
+
+    highlighted_jit_text = (
+        f"<span class='{filter_name}'>"
+        + text_highlighting.get_highlighted_text(
+            am_config=am_config,
+            morphemes=card_morphs,
+            text=_dehtml(field_text),
+            ruby_type=_get_ruby_type(filter_name),
+        )
+        + "</span>"
+    )
+
+    debug_utils.dev_print(f"highlighted_jit_text: {highlighted_jit_text}")
+
+    return highlighted_jit_text
+
+
+def _get_morph_meta_for_text(
+    morphemizer: Morphemizer,
+    field_text: str,
+    am_config: AnkiMorphsConfig,
+) -> list[Morpheme]:
+    """Take in a string and gather the morphemes from it."""
+
+    # If we were piped in after the `furigana` built-in filter, or if there is html in the source
+    # data, we need to do some cleansing.
+    clean_text = _dehtml(field_text, am_config, True)
+
+    if isinstance(morphemizer, SpacyMorphemizer):
+        nlp = spacy_wrapper.get_nlp(
+            morphemizer.get_description().removeprefix("spaCy: ")
+        )
+
+        morphs = text_preprocessing.get_processed_spacy_morphs(
+            am_config, next(nlp.pipe([clean_text]))
+        )
+    else:
+        morphs = text_preprocessing.get_processed_morphemizer_morphs(
+            morphemizer, clean_text, am_config
+        )
+
+    morphs = list(set(morphs))
+
+    if not morphs:
+        return []
+
+    with AnkiMorphsDB() as am_db:
+        for morph in morphs:
+            if am_config.evaluate_morph_inflection:
+                morph.highest_inflection_learning_interval = (
+                    am_db.get_highest_inflection_learning_interval(morph) or 0
+                )
+            else:
+                morph.highest_lemma_learning_interval = (
+                    am_db.get_highest_lemma_learning_interval(morph) or 0
+                )
+
+    return morphs
+
+
+def _dehtml(
+    text: str,
+    am_config: AnkiMorphsConfig | None = None,
+    clean_html: bool = False,
+) -> str:
+    """Prepare a string to be passed to a morphemizer. Specially process <ruby><rt> tags to extract
+    ruby to reconstruct base/ruby ruby shorthand. Remove all html from the input string.
+    """
+
+    # Capture html ruby ruby. The built in furigana filter will turn X[yz] into
+    # <ruby><rb>X</rb><rt>yz</rt></ruby>, and if we blindly strip out all html we will loose
+    # information on the ruby. Find <rt> tags and capture all text between them in a capture
+    # group called ruby, allow for any attributes or other decorations on the <rt> tag by
+    # non-eagerly capturing all chars up to '>', so that the whole element can just be dropped.
+    # non-eagerly capture one or more characters into the capture group named ruby.
+    # Samples:
+    # <ruby><rb>X</rb><rt>yz</rt></ruby> = ` X[yz]`
+    # <ruby>X<rt>yz</rt></ruby> = ` X[yz]`
+    # <ruby>X<rt class='foo'>234</rt>sdf</ruby> = ` X[234]sdf`
+    # <ruby>X<rt >>234</rt>sdf</ruby> = ` X[>234]sdf`
+    # <ruby>X<rt></rt></ruby> = Will not match
+    ruby_longhand = r"(?:<ruby[^<]*>)(?:<rb[^>]*>|.{0})(?P<base>.*?)(?:</rb>|.{0})<rt[^>]*>(?P<ruby>.+?)</rt>(?P<after>.*?)(?:</ruby>)"
+
+    # Emit the captured ruby into square brackets, thus reconstructing the ruby shorthand "X[yz]".
+    # Pad with a leading space so that we can retain the base/ruby relationship
+    ruby_shorthand = r" \g<base>[\g<ruby>]\g<after>"
+
+    text = re.sub(ruby_longhand, ruby_shorthand, text, flags=re.IGNORECASE).strip()
+
+    if clean_html:
+        text = anki.utils.strip_html(text)
+
+    return text_preprocessing.get_processed_text(am_config, text) if am_config else text
+
+
+def _get_ruby_type(filter_name: str) -> str:
+    """Get local styles for this run, based on the filter name."""
+
+    if filter_name == "am-highlight-furigana":
+        return "furigana"
+    if filter_name == "am-highlight-kanji":
+        return "kanji"
+    if filter_name == "am-highlight-kana":
+        return "kana"
+
+    return "text"