dictz 0.0.2__py3-none-any.whl

dictz/__init__.py

@@ -0,0 +1,2 @@
+"""dictz — a cross-platform multi-format offline dictionary application."""
+__version__ = "0.0.2"

dictz/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m dictz` to launch the app."""
+from .app import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dictz/app.py

@@ -0,0 +1,65 @@
+"""dictz application entry point.
+
+Run with:
+    python -m dictz
+    # or after `pip install -e .`:
+    dictz
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from PySide6.QtWidgets import QApplication
+
+from .core.query_manager import QueryManager
+from .storage.indexer import IndexStore
+from .ui.main_window import MainWindow
+
+__version__ = "0.0.2"
+APP_NAME = "dictz"
+
+
+def user_data_dir() -> Path:
+    """Cross-platform per-user data directory.
+
+    - Windows:  %APPDATA%\\dictz
+    - macOS:    ~/Library/Application Support/dictz
+    - Linux:    $XDG_DATA_HOME/dictz  (fallback ~/.local/share/dictz)
+    """
+    if sys.platform == "win32":
+        base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        return base / APP_NAME
+    elif sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / APP_NAME
+    else:
+        xdg = os.environ.get("XDG_DATA_HOME")
+        base = Path(xdg) if xdg else Path.home() / ".local" / "share"
+        return base / APP_NAME.lower()
+
+
+def main() -> int:
+    app = QApplication(sys.argv)
+    app.setApplicationName(APP_NAME)
+    app.setApplicationVersion(__version__)
+    app.setOrganizationName("Bayram Kotan")
+    app.setOrganizationDomain("bayramkotan.com")
+
+    data_dir = user_data_dir()
+    data_dir.mkdir(parents=True, exist_ok=True)
+    index_path = data_dir / "dictz_index.db"
+
+    index_store = IndexStore(index_path)
+    index_store.open()
+
+    query_manager = QueryManager(index_store=index_store)
+
+    window = MainWindow(query_manager)
+    window.show()
+
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dictz/core/query_manager.py

@@ -0,0 +1,126 @@
+"""Query manager: orchestrates lookups across all loaded dictionaries.
+
+The query manager keeps a list of loaded `Dictionary` instances and dispatches
+a single user query to all of them, collecting and ranking the results.
+
+For v0.0.2 we run lookups sequentially. Parallelization with QThreadPool comes
+in a later version when big glossary loading becomes a bottleneck.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..parsers.babylon import BabylonDictionary
+from ..parsers.base import Dictionary, DictionaryEntry
+from ..parsers.dsl import DSLDictionary
+from ..parsers.stardict import StarDictDictionary
+from ..storage.indexer import IndexStore
+
+
+# File-extension -> parser class. `.dsl.dz` is handled by peeling the .dz
+# compression suffix before the lookup.
+_PARSER_REGISTRY: dict[str, type[Dictionary]] = {
+    ".ifo": StarDictDictionary,
+    ".dsl": DSLDictionary,
+    ".bgl": BabylonDictionary,
+}
+
+
+def parser_for(path: Path | str) -> type[Dictionary]:
+    """Pick a parser class based on file extension.
+
+    Handles compressed forms (.dsl.dz, .gls.dz) by peeling the .dz suffix.
+    """
+    p = Path(path)
+    suffix = p.suffix.lower()
+
+    # Strip dictzip compression layer
+    if suffix == ".dz":
+        inner_suffix = p.with_suffix("").suffix.lower()
+        if inner_suffix in _PARSER_REGISTRY:
+            return _PARSER_REGISTRY[inner_suffix]
+
+    if suffix in _PARSER_REGISTRY:
+        return _PARSER_REGISTRY[suffix]
+
+    raise ValueError(f"No parser registered for file: {p}")
+
+
+def supported_extensions() -> list[str]:
+    """List of extensions the current build can open."""
+    return sorted(_PARSER_REGISTRY.keys())
+
+
+class QueryManager:
+    """Orchestrates dictionary loading and multi-dictionary lookups."""
+
+    def __init__(self, index_store: IndexStore | None = None):
+        self.dictionaries: dict[str, Dictionary] = {}
+        self.index_store = index_store
+
+    def add_dictionary(self, path: Path | str, reindex: bool = False) -> Dictionary:
+        parser_cls = parser_for(path)
+        dictionary = parser_cls(path)
+        dictionary.load()
+        self.dictionaries[dictionary.metadata.name] = dictionary
+
+        if self.index_store is not None:
+            already_indexed = self.index_store.is_indexed(dictionary.metadata.name)
+            if reindex or not already_indexed:
+                self.index_store.index_dictionary(dictionary)
+
+        return dictionary
+
+    def remove_dictionary(self, name: str) -> None:
+        if name in self.dictionaries:
+            self.dictionaries[name].close()
+            del self.dictionaries[name]
+        if self.index_store is not None:
+            self.index_store.remove_dictionary(name)
+
+    def loaded_names(self) -> list[str]:
+        return sorted(self.dictionaries.keys())
+
+    def search(self, word: str, exact: bool = True) -> list[DictionaryEntry]:
+        if not word.strip():
+            return []
+
+        results: list[DictionaryEntry] = []
+        for name, dictionary in self.dictionaries.items():
+            try:
+                entries = dictionary.lookup(word, exact=exact)
+            except Exception as e:
+                print(f"[dictz] lookup failed in {name}: {e}")
+                continue
+            results.extend(entries)
+        return results
+
+    def suggest(self, prefix: str, limit: int = 30) -> list[str]:
+        if not prefix.strip():
+            return []
+
+        if self.index_store is not None:
+            rows = self.index_store.search_headword(prefix, limit=limit)
+            seen: set[str] = set()
+            out: list[str] = []
+            for headword, _ in rows:
+                if headword not in seen:
+                    seen.add(headword)
+                    out.append(headword)
+            return out
+
+        seen = set()
+        out = []
+        for dictionary in self.dictionaries.values():
+            for entry in dictionary.lookup(prefix, exact=False):
+                if entry.headword not in seen:
+                    seen.add(entry.headword)
+                    out.append(entry.headword)
+                    if len(out) >= limit:
+                        return out
+        return out
+
+    def close_all(self) -> None:
+        for dictionary in self.dictionaries.values():
+            dictionary.close()
+        self.dictionaries.clear()

dictz/parsers/babylon.py

@@ -0,0 +1,16 @@
+"""Babylon (.bgl) dictionary parser.
+
+Babylon is a proprietary binary format from the Babylon translator. The format
+was reverse-engineered years ago; PyGlossary includes a mature parser that
+handles the binary encoding, embedded images, and multi-byte character sets.
+"""
+from __future__ import annotations
+
+from .pyglossary_base import PyGlossaryDictionary
+
+
+class BabylonDictionary(PyGlossaryDictionary):
+    """Babylon binary dictionary (.bgl)."""
+
+    _format = "BabylonBgl"
+    format_label = "babylon"

dictz/parsers/base.py

@@ -0,0 +1,104 @@
+"""Abstract base class for all dictionary format parsers.
+
+Every concrete parser (StarDict, DSL, Babylon) implements this interface,
+so the rest of the application can treat dictionaries uniformly regardless
+of their underlying file format.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterator
+
+
+@dataclass
+class DictionaryEntry:
+    """A single headword + definition pair from a dictionary."""
+
+    headword: str
+    definition: str  # HTML or plain text
+    dictionary_id: str = ""  # filled in by the query manager
+    score: float = 1.0  # 1.0 = exact match, <1.0 = fuzzy match similarity
+
+    def __repr__(self) -> str:
+        preview = self.definition[:50].replace("\n", " ")
+        return f"DictionaryEntry({self.headword!r}, {preview!r}...)"
+
+
+@dataclass
+class DictionaryMetadata:
+    """Information about a loaded dictionary."""
+
+    name: str
+    source_language: str = ""
+    target_language: str = ""
+    description: str = ""
+    author: str = ""
+    word_count: int = 0
+    file_path: Path = field(default_factory=Path)
+    format: str = ""  # "stardict", "dsl", "babylon"
+
+    @property
+    def display_name(self) -> str:
+        if self.source_language and self.target_language:
+            return f"{self.name} ({self.source_language} → {self.target_language})"
+        return self.name
+
+
+class Dictionary(ABC):
+    """Abstract base for all dictionary format parsers.
+
+    Lifecycle:
+        1. __init__(path)        — store the path, do nothing expensive
+        2. load()                — read headers, build internal index
+        3. lookup(word) / iter_entries() — used by query manager
+        4. close()               — release file handles
+    """
+
+    def __init__(self, path: Path | str):
+        self.path = Path(path)
+        self.metadata = DictionaryMetadata(name=self.path.stem, file_path=self.path)
+        self._loaded = False
+
+    @property
+    def loaded(self) -> bool:
+        return self._loaded
+
+    @abstractmethod
+    def load(self) -> None:
+        """Load dictionary headers and build an in-memory index.
+
+        Should populate self.metadata. Heavy I/O is expected here.
+        """
+        ...
+
+    @abstractmethod
+    def lookup(self, word: str, exact: bool = True) -> list[DictionaryEntry]:
+        """Look up a word. Returns 0 or more matching entries.
+
+        Args:
+            word: The headword to search for (case-insensitive by default).
+            exact: If True, only exact matches. If False, prefix matches too.
+        """
+        ...
+
+    @abstractmethod
+    def iter_entries(self) -> Iterator[DictionaryEntry]:
+        """Yield every entry in the dictionary (used for full indexing)."""
+        ...
+
+    def close(self) -> None:
+        """Release any open file handles. Default: no-op."""
+        self._loaded = False
+
+    def __enter__(self):
+        if not self._loaded:
+            self.load()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.metadata.name!r} ({self.metadata.word_count} words)>"

dictz/parsers/dsl.py

@@ -0,0 +1,20 @@
+"""DSL (ABBYY Lingvo) dictionary parser.
+
+DSL is a text-based markup format used by ABBYY Lingvo. Files end in .dsl
+(or .dsl.dz when dictzip-compressed) and contain headwords followed by
+indented, markup-rich definitions.
+
+We delegate the actual parsing to PyGlossary's ABBYYLingvoDSL plugin, which
+handles the markup (phonetic brackets, cross-references, formatting tags)
+and converts it to HTML.
+"""
+from __future__ import annotations
+
+from .pyglossary_base import PyGlossaryDictionary
+
+
+class DSLDictionary(PyGlossaryDictionary):
+    """ABBYY Lingvo DSL dictionary (.dsl / .dsl.dz)."""
+
+    _format = "ABBYYLingvoDSL"
+    format_label = "dsl"

dictz/parsers/pyglossary_base.py

@@ -0,0 +1,171 @@
+"""PyGlossary-backed base parser.
+
+PyGlossary is a mature multi-format converter library that can read 60+
+dictionary formats. We wrap it behind our own Dictionary interface so the
+rest of dictz doesn't need to know about PyGlossary's quirks.
+
+For each supported format (DSL, Babylon, etc.) we subclass PyGlossaryDictionary
+and set `_format` to the PyGlossary plugin name. Everything else is shared:
+headers, iteration, exact and prefix lookup.
+
+The PyGlossary Glossary.init() call is global and expensive (it loads every
+plugin module). We call it once per process via _ensure_init().
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterator
+
+from .base import Dictionary, DictionaryEntry
+
+
+_pyglossary_initialized = False
+
+
+def _ensure_init() -> None:
+    """Call Glossary.init() exactly once per process."""
+    global _pyglossary_initialized
+    if _pyglossary_initialized:
+        return
+    try:
+        from pyglossary.glossary_v2 import Glossary
+    except ImportError as exc:
+        raise ImportError(
+            "pyglossary is required for DSL/Babylon support. "
+            "Install with: pip install pyglossary"
+        ) from exc
+    Glossary.init()
+    _pyglossary_initialized = True
+
+
+class PyGlossaryError(Exception):
+    """Raised when PyGlossary fails to read a dictionary file."""
+
+
+class PyGlossaryDictionary(Dictionary):
+    """Generic PyGlossary-backed dictionary.
+
+    Subclasses set:
+        _format: the PyGlossary plugin name (e.g. "ABBYYLingvoDSL", "Babylon")
+        format_label: the human-readable format label stored in metadata
+    """
+
+    _format: str = ""  # overridden by subclass
+    format_label: str = ""  # overridden by subclass
+
+    def __init__(self, path: Path | str):
+        super().__init__(path)
+        # word -> definition (loaded eagerly on load() — PyGlossary doesn't
+        # offer cheap random access for most formats, so we materialize the
+        # whole dictionary in memory on first load, then serve lookups from
+        # the dict. For very large glossaries this trades memory for speed.
+        self._entries: dict[str, str] = {}
+        self._sorted_words: list[str] = []
+        self.metadata.format = self.format_label
+
+    # ------------------------------------------------------------------ load
+
+    def load(self) -> None:
+        if self._loaded:
+            return
+        if not self._format:
+            raise PyGlossaryError(
+                f"{self.__class__.__name__} did not set _format"
+            )
+        if not self.path.exists():
+            raise PyGlossaryError(f"File not found: {self.path}")
+
+        _ensure_init()
+        from pyglossary.glossary_v2 import Glossary
+
+        glos = Glossary()
+        try:
+            opened = glos.directRead(str(self.path), formatName=self._format)
+        except Exception as exc:
+            raise PyGlossaryError(
+                f"PyGlossary could not read {self.path}: {exc}"
+            ) from exc
+
+        if not opened:
+            raise PyGlossaryError(
+                f"PyGlossary refused to open {self.path} as {self._format}"
+            )
+
+        # Pull header fields
+        self.metadata.name = glos.getInfo("name") or glos.getInfo("title") or self.path.stem
+        self.metadata.author = glos.getInfo("author") or ""
+        self.metadata.description = glos.getInfo("description") or ""
+        self.metadata.source_language = glos.getInfo("sourceLang") or ""
+        self.metadata.target_language = glos.getInfo("targetLang") or ""
+
+        # Materialize all entries. PyGlossary iterates once in direct mode.
+        for entry in glos:
+            if entry is None:
+                continue
+            # Skip resource entries (images, sounds, binary blobs)
+            if getattr(entry, "isData", lambda: False)():
+                continue
+            # PyGlossary 5.0+ renamed s_word -> s_term; keep a fallback.
+            word = getattr(entry, "s_term", None) or getattr(entry, "s_word", "") or ""
+            defi = entry.defi or ""
+            if not word:
+                continue
+            # A headword can have multiple variants; PyGlossary gives them as
+            # a single `\n`-separated string in s_word. Register them all.
+            variants = [w.strip() for w in word.split("|") if w.strip()]
+            if not variants:
+                variants = [word]
+            for variant in variants:
+                if variant not in self._entries:
+                    self._entries[variant] = defi
+
+        self.metadata.word_count = len(self._entries)
+        self._sorted_words = sorted(self._entries.keys(), key=str.lower)
+        self._loaded = True
+
+    # ---------------------------------------------------------------- lookup
+
+    def lookup(self, word: str, exact: bool = True) -> list[DictionaryEntry]:
+        if not self._loaded:
+            self.load()
+
+        results: list[DictionaryEntry] = []
+
+        if word in self._entries:
+            results.append(self._entry_for(word))
+
+        if not results:
+            word_lower = word.lower()
+            for indexed_word in self._sorted_words:
+                if indexed_word.lower() == word_lower:
+                    results.append(self._entry_for(indexed_word))
+                    break
+
+        if not exact and not results:
+            word_lower = word.lower()
+            for indexed_word in self._sorted_words:
+                if indexed_word.lower().startswith(word_lower):
+                    results.append(self._entry_for(indexed_word))
+                    if len(results) >= 50:
+                        break
+
+        return results
+
+    def _entry_for(self, word: str) -> DictionaryEntry:
+        return DictionaryEntry(
+            headword=word,
+            definition=self._entries[word],
+            dictionary_id=self.metadata.name,
+            score=1.0,
+        )
+
+    def iter_entries(self) -> Iterator[DictionaryEntry]:
+        if not self._loaded:
+            self.load()
+        for word in self._sorted_words:
+            yield self._entry_for(word)
+
+    def close(self) -> None:
+        self._entries.clear()
+        self._sorted_words.clear()
+        super().close()