meikipop 2.0.0__py3-none-any.whl

meikipop/__init__.py

@@ -0,0 +1,5 @@
+"""meikipop - Universal Japanese OCR popup dictionary"""
+
+__version__ = "2.0.0"
+__author__ = "rtr46"
+__license__ = "GPL-3.0"

meikipop/config/config.py

@@ -0,0 +1,110 @@
+# meikipop/config/config.py
+import configparser
+import logging
+import os
+import sys
+
+from meikipop.utils.paths import paths
+
+logger = logging.getLogger(__name__)
+
+APP_NAME = "meikipop"
+APP_VERSION = "2.0.0"
+MAX_DICT_ENTRIES = 10
+IS_LINUX = sys.platform.startswith('linux')
+IS_WINDOWS = sys.platform.startswith('win')
+IS_MACOS = sys.platform.startswith('darwin')
+# todo should we use this instead?: IS_WAYLAND = IS_LINUX and bool(os.environ.get('WAYLAND_DISPLAY'))
+IS_WAYLAND = IS_LINUX and os.environ.get('XDG_SESSION_TYPE', '').lower() == 'wayland'
+
+# Force xwayland so windows can pop up in arbitary locations
+if IS_WAYLAND:
+    os.environ['QT_QPA_PLATFORM'] = 'xcb'
+
+CONFIG_PATH = paths.config_path
+DICT_PATH = paths.dictionary_path
+
+class Config:
+    _instance = None
+
+    _SCHEMA = {
+        'Settings': {
+            'hotkey': 'shift',
+            'scan_region': 'region',
+            'max_lookup_length': 25,
+            'glens_low_bandwidth': False,
+            'ocr_provider': 'meikiocr (local)',
+            'auto_scan_mode': True,
+            'auto_scan_mode_lookups_without_hotkey': True,
+            'auto_scan_interval_seconds': 0.5,
+            'auto_scan_on_mouse_move': True,
+            'magpie_compatibility': True
+        },
+        'Theme': {
+            'theme_name': 'Nazeka',
+            'font_family': '',
+            'font_size_definitions': 14,
+            'font_size_header': 18,
+            'compact_mode': True,
+            'show_all_glosses': False,
+            'show_deconjugation': False,
+            'show_pos': False,
+            'show_tags': False,
+            'show_frequency': False,
+            'show_kanji': True,
+            'show_examples': True,
+            'show_components': True,
+            'color_background': '#2E2E2E',
+            'color_foreground': '#F0F0F0',
+            'color_highlight_word': '#88D8FF',
+            'color_highlight_reading': '#90EE90',
+            'background_opacity': 245,
+            'popup_position_mode': 'visual_novel_mode'
+        }
+    }
+
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+            cls._instance._load()
+        return cls._instance
+
+    def _load(self):
+        parser = configparser.ConfigParser()
+        found = parser.read(CONFIG_PATH, encoding='utf-8')
+
+        for section, settings in self._SCHEMA.items():
+            for key, default in settings.items():
+                if parser.has_option(section, key):
+                    if isinstance(default, bool):
+                        val = parser.getboolean(section, key)
+                    elif isinstance(default, int):
+                        val = parser.getint(section, key)
+                    elif isinstance(default, float):
+                        val = parser.getfloat(section, key)
+                    else:
+                        val = parser.get(section, key)
+                else:
+                    val = default
+                setattr(self, key, val)
+
+        self.is_enabled = True
+        if found:
+            logger.info(f"Configuration loaded from '{CONFIG_PATH}'.")
+        else:
+            logger.info(f"No configuration found at '{CONFIG_PATH}'. A new one will be created with default values.")
+
+    def save(self):
+        parser = configparser.ConfigParser()
+        for section, settings in self._SCHEMA.items():
+            parser.add_section(section)
+            for key in settings:
+                val = getattr(self, key)
+                parser.set(section, key, str(val).lower() if isinstance(val, bool) else str(val))
+
+        with open(CONFIG_PATH, 'w', encoding='utf-8') as f:
+            parser.write(f)
+        logger.info(f"Settings saved to '{CONFIG_PATH}'.")
+
+
+config = Config()

meikipop/dictionary/customdict.py

@@ -0,0 +1,160 @@
+# customdict.py
+import logging
+import pickle
+import time
+import urllib.request
+import zipfile
+import io
+from collections import defaultdict
+
+from meikipop.utils.paths import paths
+
+logger = logging.getLogger(__name__)
+
+DICT_URL = "https://github.com/rtr46/meikipop/releases/download/dictionary-latest/dictionary.zip"
+
+DEFAULT_FREQ = 999_999
+
+# MapEntry tuple field indices. value: (written_form, reading, freq, entry_id)
+WRITTEN_FORM_INDEX = 0
+READING_INDEX = 1
+FREQUENCY_INDEX = 2
+ENTRY_ID_INDEX = 3
+
+class Dictionary:
+    def __init__(self):
+        # Core entries: {entry_id: [sense, ...]}
+        # Each sense: {'glosses': [...], 'pos': [...], 'misc': [...]}
+        self.entries: dict[int, list] = {}
+
+        # lookup_map: surface_form → [(written_form, reading_or_None, freq, entry_id), ...]
+        self.lookup_map: dict[str, list] = defaultdict(list)
+
+        # Kanji character entries from kanjidic2: {character: {...}}
+        self.kanji_entries: dict[str, dict] = {}
+
+        # Deconjugation rules consumed by Deconjugator at runtime
+        self.deconjugator_rules: list[dict] = []
+
+        self._is_loaded = False
+
+    def load_dictionary(self, file_path: str) -> bool:
+        if self._is_loaded:
+            return True
+        logger.info(f"Loading dictionary from '{file_path}'")
+        start = time.perf_counter()
+        try:
+            with open(file_path, 'rb') as f:
+                data = pickle.load(f)
+            self.entries            = data['entries']
+            self.lookup_map         = data['lookup_map']
+            self.kanji_entries      = data.get('kanji_entries', {})
+            self.deconjugator_rules = data.get('deconjugator_rules', [])
+            self._is_loaded = True
+            n_refs = sum(len(v) for v in self.lookup_map.values())
+            logger.info(
+                f"Dictionary loaded in {time.perf_counter() - start:.2f}s"
+                f"({len(self.entries)} core entries, {n_refs} lookup refs)"
+            )
+            self._validate()
+            return True
+        except FileNotFoundError:
+            logger.warning(f"Dictionary file not found. Trying download...")
+            if self._download_dictionary():
+                return self.load_dictionary(file_path)  # retry once after download
+            logger.error(
+                "Dictionary could not be downloaded. "
+                "You can build it manually by running 'meikipop build-dict'."
+            )
+            return False
+        except Exception as e:
+            logger.error(f"Failed to load dictionary: {e}")
+            return False
+
+    def _download_dictionary(self) -> bool:
+        try:
+            with urllib.request.urlopen(DICT_URL) as response:
+                data = response.read()
+            with zipfile.ZipFile(io.BytesIO(data)) as zf:
+                zf.extract("dictionary.pkl", path=paths.data_dir)
+            logger.info("Dictionary downloaded successfully.")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to download dictionary: {e}")
+            return False
+
+
+    def _validate(self):
+        """
+        Scan the loaded dictionary for structural invariants and log warnings
+        for any violations found. Never raises — validation is advisory only.
+
+        Invariants checked:
+          - Every map entry tuple has exactly 4 elements
+          - written_form is a non-empty str or None (None is valid for kana-only)
+          - reading is a str or None
+          - freq is an int
+          - entry_id exists in self.entries
+          - A map entry reached via a kanji-containing key must not have
+            written_form=None (that would render as an invisible entry)
+        """
+        issues = 0
+        missing_entry_ids = set()
+
+        for surface, me_list in self.lookup_map.items():
+            surface_has_kanji = any(0x4E00 <= ord(c) <= 0x9FFF for c in surface)
+            for me in me_list:
+                if len(me) != 4:
+                    logger.warning(
+                        f"Malformed map entry under key '{surface}': "
+                        f"expected 4 fields, got {len(me)} — {me!r}"
+                    )
+                    issues += 1
+                    continue
+
+                wf, rd, freq, entry_id = me
+
+                if wf is not None and not isinstance(wf, str):
+                    logger.warning(
+                        f"Map entry under '{surface}': written_form is {type(wf).__name__} "
+                        f"(expected str or None) — entry_id={entry_id}"
+                    )
+                    issues += 1
+
+                if rd is not None and not isinstance(rd, str):
+                    logger.warning(
+                        f"Map entry under '{surface}': reading is {type(rd).__name__} "
+                        f"(expected str or None) — entry_id={entry_id}"
+                    )
+                    issues += 1
+
+                if not isinstance(freq, int):
+                    logger.warning(
+                        f"Map entry under '{surface}': freq is {type(freq).__name__} "
+                        f"(expected int) — entry_id={entry_id}"
+                    )
+                    issues += 1
+
+                if surface_has_kanji and wf is None:
+                    logger.warning(
+                        f"Map entry under kanji key '{surface}' has written_form=None "
+                        f"(entry will display incorrectly) — entry_id={entry_id}"
+                    )
+                    issues += 1
+
+                if entry_id not in self.entries:
+                    missing_entry_ids.add(entry_id)
+                    issues += 1
+
+        if missing_entry_ids:
+            logger.warning(
+                f"{len(missing_entry_ids)} entry ID(s) referenced in lookup_map "
+                f"have no matching core entry — first few: "
+                f"{sorted(missing_entry_ids)[:5]}"
+            )
+
+        if issues == 0:
+            logger.info("Dictionary validation passed with no issues.")
+        else:
+            logger.warning(f"Dictionary validation found {issues} issue(s) — "
+                           f"some entries may display incorrectly.")

meikipop/dictionary/deconjugator.py

@@ -0,0 +1,109 @@
+# deconjugator.py
+from dataclasses import dataclass, field
+from typing import Set
+
+MAX_DECONJ_ITERATIONS = 10
+
+@dataclass(frozen=True)
+class Form:
+    text: str
+    process: tuple = field(default_factory=tuple)
+    tags: tuple = field(default_factory=tuple)
+
+    def __repr__(self):
+        return f"Form(text='{self.text}', process={self.process}, tags={self.tags})"
+
+class Deconjugator:
+    def __init__(self, rules: list[dict]):
+        self.rules = [r for r in rules if isinstance(r, dict)]
+
+    def deconjugate(self, text: str) -> Set[Form]:
+        clean_text = text.strip()
+        if not clean_text:
+            return set()
+
+        processed: Set[Form] = set()
+        novel: Set[Form] = {Form(text=clean_text)}
+
+        iteration = 0
+        while novel:
+            iteration += 1
+            if iteration > MAX_DECONJ_ITERATIONS: break
+
+            new_novel: Set[Form] = set()
+            for form in novel:
+                for rule in self.rules:
+                    rule_type = rule.get('type')
+                    if not rule_type or rule_type == 'substitution': continue
+
+                    if rule_type == 'onlyfinalrule' and form.tags: continue
+                    if rule_type == 'neverfinalrule' and not form.tags: continue
+
+                    new_forms = self._apply_rule(form, rule)
+                    if new_forms:
+                        for f in new_forms:
+                            if f not in processed and f not in novel and f not in new_novel:
+                                new_novel.add(f)
+
+            processed.update(novel)
+            novel = new_novel
+
+        processed.add(Form(text=clean_text))
+        return processed
+
+    def _apply_rule(self, form: Form, rule: dict) -> Set[Form] | None:
+        if 'dec_end' not in rule or 'con_end' not in rule:
+            return None
+
+        dec_ends = rule['dec_end'] if isinstance(rule['dec_end'], list) else [rule['dec_end']]
+        con_ends = rule['con_end'] if isinstance(rule['con_end'], list) else [rule['con_end']]
+
+        con_tags_from_rule = rule.get('con_tag')
+        dec_tags_from_rule = rule.get('dec_tag')
+
+        con_tags = [con_tags_from_rule] if con_tags_from_rule and not isinstance(con_tags_from_rule,
+                                                                                 list) else con_tags_from_rule
+        dec_tags = [dec_tags_from_rule] if dec_tags_from_rule and not isinstance(dec_tags_from_rule,
+                                                                                 list) else dec_tags_from_rule
+
+        max_len = 1
+        list_source = next((lst for lst in [dec_ends, con_ends, dec_tags, con_tags] if isinstance(lst, list)), None)
+        if list_source: max_len = len(list_source)
+
+        results = set()
+
+        for i in range(max_len):
+            con_end = con_ends[i % len(con_ends)] if con_ends else ""
+            con_tag = con_tags[i % len(con_tags)] if con_tags else None
+            dec_end = dec_ends[i % len(dec_ends)] if dec_ends else ""
+            dec_tag = dec_tags[i % len(dec_tags)] if dec_tags else None
+
+            suffix_match = form.text.endswith(con_end)
+
+            current_form_tag = form.tags[-1] if form.tags else None
+            tag_match = False
+            is_starter_type = rule.get('type') in ['stdrule', 'rewriterule', 'onlyfinalrule', 'contextrule']
+
+            if not form.tags and is_starter_type:
+                tag_match = True
+            elif form.tags:
+                tag_match = (current_form_tag == con_tag)
+
+            if not suffix_match or not tag_match:
+                continue
+
+            if rule.get('type') == 'rewriterule' and form.text != con_end:
+                continue
+
+            new_text = form.text[:-len(con_end)] + dec_end if con_end else form.text + dec_end
+            new_process = form.process + (rule.get('detail', ''),)
+
+            if form.tags:
+                new_tags = form.tags[:-1] + (dec_tag,) if dec_tag is not None else form.tags[:-1]
+            else:
+                new_tags = (dec_tag,) if dec_tag is not None else ()
+
+            new_form_to_add = Form(text=new_text, process=new_process, tags=new_tags)
+            results.add(new_form_to_add)
+
+        return results if results else None