ankigammon 1.0.6__py3-none-any.whl

ankigammon/settings.py

@@ -0,0 +1,315 @@
+"""
+Settings and configuration management for AnkiGammon.
+
+Handles loading and saving user preferences such as color scheme selection.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+
+class Settings:
+    """Manages application settings with persistence."""
+
+    DEFAULT_SETTINGS = {
+        "default_color_scheme": "classic",
+        "deck_name": "My AnkiGammon Deck",
+        "show_options": True,
+        "interactive_moves": True,
+        "export_method": "ankiconnect",
+        "gnubg_path": None,
+        "gnubg_analysis_ply": 3,
+        "generate_score_matrix": False,
+        "board_orientation": "counter-clockwise",
+        "last_apkg_directory": None,
+        "import_error_threshold": 0.080,
+        "import_include_player_x": True,
+        "import_include_player_o": True,
+        "import_selected_player_names": [],
+        "max_mcq_options": 5,
+        "check_for_updates": True,
+        "last_update_check": None,
+        "snooze_update_until": None,
+    }
+
+    def __init__(self, config_path: Optional[Path] = None):
+        """
+        Initialize settings manager.
+
+        Args:
+            config_path: Path to config file. If None, uses default location.
+        """
+        if config_path is None:
+            config_dir = Path.home() / ".ankigammon"
+            config_dir.mkdir(parents=True, exist_ok=True)
+            config_path = config_dir / "config.json"
+
+        self.config_path = config_path
+        self._settings = self._load()
+
+    def _load(self) -> dict:
+        """Load settings from config file."""
+        if not self.config_path.exists():
+            return self.DEFAULT_SETTINGS.copy()
+
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                loaded = json.load(f)
+                # Merge with defaults to ensure new settings have default values
+                settings = self.DEFAULT_SETTINGS.copy()
+                settings.update(loaded)
+                return settings
+        except (json.JSONDecodeError, IOError):
+            # Use defaults if file is corrupted or unreadable
+            return self.DEFAULT_SETTINGS.copy()
+
+    def _save(self) -> None:
+        """Save settings to config file."""
+        try:
+            with open(self.config_path, 'w', encoding='utf-8') as f:
+                json.dump(self._settings, f, indent=2)
+        except IOError:
+            # Silently fail if unable to save
+            pass
+
+    def get(self, key: str, default=None):
+        """Get a setting value."""
+        return self._settings.get(key, default)
+
+    def set(self, key: str, value) -> None:
+        """Set a setting value and save to disk."""
+        self._settings[key] = value
+        self._save()
+
+    @property
+    def color_scheme(self) -> str:
+        """Get the default color scheme."""
+        return self._settings.get("default_color_scheme", "classic")
+
+    @color_scheme.setter
+    def color_scheme(self, value: str) -> None:
+        """Set the default color scheme."""
+        self.set("default_color_scheme", value)
+
+    @property
+    def deck_name(self) -> str:
+        """Get the default deck name."""
+        return self._settings.get("deck_name", "My AnkiGammon Deck")
+
+    @deck_name.setter
+    def deck_name(self, value: str) -> None:
+        """Set the default deck name."""
+        self.set("deck_name", value)
+
+    @property
+    def show_options(self) -> bool:
+        """Get whether to show options on cards."""
+        return self._settings.get("show_options", True)
+
+    @show_options.setter
+    def show_options(self, value: bool) -> None:
+        """Set whether to show options on cards."""
+        self.set("show_options", value)
+
+    @property
+    def interactive_moves(self) -> bool:
+        """Get whether to enable interactive move visualization."""
+        return self._settings.get("interactive_moves", True)
+
+    @interactive_moves.setter
+    def interactive_moves(self, value: bool) -> None:
+        """Set whether to enable interactive move visualization."""
+        self.set("interactive_moves", value)
+
+    @property
+    def export_method(self) -> str:
+        """Get the default export method."""
+        return self._settings.get("export_method", "ankiconnect")
+
+    @export_method.setter
+    def export_method(self, value: str) -> None:
+        """Set the default export method."""
+        self.set("export_method", value)
+
+    @property
+    def gnubg_path(self) -> Optional[str]:
+        """Get the GnuBG executable path."""
+        return self._settings.get("gnubg_path", None)
+
+    @gnubg_path.setter
+    def gnubg_path(self, value: Optional[str]) -> None:
+        """Set the GnuBG executable path."""
+        self.set("gnubg_path", value)
+
+    @property
+    def gnubg_analysis_ply(self) -> int:
+        """Get the GnuBG analysis depth (ply)."""
+        return self._settings.get("gnubg_analysis_ply", 3)
+
+    @gnubg_analysis_ply.setter
+    def gnubg_analysis_ply(self, value: int) -> None:
+        """Set the GnuBG analysis depth (ply)."""
+        self.set("gnubg_analysis_ply", value)
+
+    @property
+    def generate_score_matrix(self) -> bool:
+        """Get whether to generate score matrix for cube decisions."""
+        return self._settings.get("generate_score_matrix", False)
+
+    @generate_score_matrix.setter
+    def generate_score_matrix(self, value: bool) -> None:
+        """Set whether to generate score matrix for cube decisions."""
+        self.set("generate_score_matrix", value)
+
+    @property
+    def board_orientation(self) -> str:
+        """Get the board orientation (clockwise or counter-clockwise)."""
+        return self._settings.get("board_orientation", "counter-clockwise")
+
+    @board_orientation.setter
+    def board_orientation(self, value: str) -> None:
+        """Set the board orientation (clockwise or counter-clockwise)."""
+        if value not in ["clockwise", "counter-clockwise"]:
+            raise ValueError("board_orientation must be 'clockwise' or 'counter-clockwise'")
+        self.set("board_orientation", value)
+
+    @property
+    def last_apkg_directory(self) -> Optional[str]:
+        """Get the last directory used for APKG export."""
+        return self._settings.get("last_apkg_directory", None)
+
+    @last_apkg_directory.setter
+    def last_apkg_directory(self, value: Optional[str]) -> None:
+        """Set the last directory used for APKG export."""
+        self.set("last_apkg_directory", value)
+
+    @property
+    def import_error_threshold(self) -> float:
+        """Get the error threshold for XG file imports."""
+        return self._settings.get("import_error_threshold", 0.080)
+
+    @import_error_threshold.setter
+    def import_error_threshold(self, value: float) -> None:
+        """Set the error threshold for XG file imports."""
+        self.set("import_error_threshold", value)
+
+    @property
+    def import_include_player_x(self) -> bool:
+        """Get whether to include Player X mistakes in imports."""
+        return self._settings.get("import_include_player_x", True)
+
+    @import_include_player_x.setter
+    def import_include_player_x(self, value: bool) -> None:
+        """Set whether to include Player X mistakes in imports."""
+        self.set("import_include_player_x", value)
+
+    @property
+    def import_include_player_o(self) -> bool:
+        """Get whether to include Player O mistakes in imports."""
+        return self._settings.get("import_include_player_o", True)
+
+    @import_include_player_o.setter
+    def import_include_player_o(self, value: bool) -> None:
+        """Set whether to include Player O mistakes in imports."""
+        self.set("import_include_player_o", value)
+
+    @property
+    def import_selected_player_names(self) -> list[str]:
+        """Get the list of previously selected player names."""
+        return self._settings.get("import_selected_player_names", [])
+
+    @import_selected_player_names.setter
+    def import_selected_player_names(self, value: list[str]) -> None:
+        """Set the list of previously selected player names."""
+        if not isinstance(value, list):
+            value = []
+
+        validated = []
+        seen = set()
+        for name in value:
+            if not isinstance(name, str):
+                continue
+
+            trimmed = name.strip()
+            if not trimmed:
+                continue
+
+            # Case-insensitive deduplication
+            key = trimmed.lower()
+            if key not in seen:
+                seen.add(key)
+                validated.append(trimmed)
+
+        self.set("import_selected_player_names", validated)
+
+    @property
+    def max_mcq_options(self) -> int:
+        """Get the maximum number of MCQ options to display."""
+        return self._settings.get("max_mcq_options", 5)
+
+    @max_mcq_options.setter
+    def max_mcq_options(self, value: int) -> None:
+        """Set the maximum number of MCQ options to display."""
+        if value < 2 or value > 10:
+            raise ValueError("max_mcq_options must be between 2 and 10")
+        self.set("max_mcq_options", value)
+
+    @property
+    def check_for_updates(self) -> bool:
+        """Get whether to check for updates on startup."""
+        return self._settings.get("check_for_updates", True)
+
+    @check_for_updates.setter
+    def check_for_updates(self, value: bool) -> None:
+        """Set whether to check for updates on startup."""
+        self.set("check_for_updates", value)
+
+    @property
+    def last_update_check(self) -> Optional[str]:
+        """Get the timestamp of the last update check (ISO format)."""
+        return self._settings.get("last_update_check", None)
+
+    @last_update_check.setter
+    def last_update_check(self, value: Optional[str]) -> None:
+        """Set the timestamp of the last update check (ISO format)."""
+        self.set("last_update_check", value)
+
+    @property
+    def snooze_update_until(self) -> Optional[str]:
+        """Get the timestamp to snooze update notifications until (ISO format)."""
+        return self._settings.get("snooze_update_until", None)
+
+    @snooze_update_until.setter
+    def snooze_update_until(self, value: Optional[str]) -> None:
+        """Set the timestamp to snooze update notifications until (ISO format)."""
+        self.set("snooze_update_until", value)
+
+    def is_gnubg_available(self) -> bool:
+        """
+        Check if GnuBG is configured and accessible.
+
+        Returns:
+            True if gnubg_path is set and the file exists and is executable.
+        """
+        path = self.gnubg_path
+        if path is None:
+            return False
+        try:
+            path_obj = Path(path)
+            return path_obj.exists() and os.access(path, os.X_OK)
+        except (OSError, ValueError):
+            return False
+
+
+# Global settings instance
+_settings = None
+
+
+def get_settings() -> Settings:
+    """Get the global settings instance."""
+    global _settings
+    if _settings is None:
+        _settings = Settings()
+    return _settings

ankigammon/thirdparty/__init__.py

@@ -0,0 +1,7 @@
+"""
+Third-party code with different licenses.
+
+This directory contains code from external projects that use licenses
+other than the main project license (MIT). Each subdirectory has its
+own LICENSE file.
+"""

ankigammon/thirdparty/xgdatatools/__init__.py

@@ -0,0 +1,17 @@
+"""
+xgdatatools - eXtreme Gammon binary file parser
+
+Original author: Michael Petch <mpetch@gnubg.org>
+License: LGPL-3.0 or later
+Source: https://github.com/oysteijo/xgdatatools
+
+This package contains the xgdatatools library for parsing eXtreme Gammon
+binary (.xg) file formats.
+"""
+
+from . import xgimport
+from . import xgstruct
+from . import xgutils
+from . import xgzarc
+
+__all__ = ['xgimport', 'xgstruct', 'xgutils', 'xgzarc']

ankigammon/thirdparty/xgdatatools/xgimport.py

@@ -0,0 +1,160 @@
+#
+#   xgimport.py - XG import module
+#   Copyright (C) 2013,2014  Michael Petch <mpetch@gnubg.org>
+#                                          <mpetch@capp-sysware.com>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Lesser General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Lesser General Public License for more details.
+#
+#   You should have received a copy of the GNU Lesser General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+from __future__ import with_statement as _with
+import tempfile as _tempfile
+import shutil as _shutil
+import struct as _struct
+import os as _os
+from . import xgutils as _xgutils
+from . import xgzarc as _xgzarc
+from . import xgstruct as _xgstruct
+
+
+class Import(object):
+
+    class Segment(object):
+        GDF_HDR, GDF_IMAGE, XG_GAMEHDR, XG_GAMEFILE, XG_ROLLOUTS, XG_COMMENT, \
+            ZLIBARC_IDX, XG_UNKNOWN = range(8)
+        EXTENSIONS = ['_gdh.bin', '.jpg', '_gamehdr.bin', '_gamefile.bin',
+                      '_rollouts.bin', '_comments.bin', '_idx.bin', None]
+        GDF_HDR_EXT, GDF_IMAGE_EXT, XG_GAMEHDR_EXT, XG_GAMEFILE_EXT, \
+            XG_ROLLOUTS_EXT, XG_COMMENTS_EXT, \
+            XG_IDX_EXT, XG_UNKNOWN = EXTENSIONS
+        XG_FILEMAP = {'temp.xgi': XG_GAMEHDR, 'temp.xgr': XG_ROLLOUTS,
+                      'temp.xgc': XG_COMMENT, 'temp.xg': XG_GAMEFILE}
+
+        XG_GAMEHDR_LEN = 556
+
+        __TMP_PREFIX = 'tmpXGI'
+
+        def __init__(self, type=GDF_HDR, delete=True, prefix=__TMP_PREFIX):
+            self.filename = None
+            self.fd = None
+            self.file = None
+            self.type = type
+            self.__prefix = prefix
+            self.__autodelete = delete
+            self.ext = self.EXTENSIONS[type]
+
+        def __enter__(self):
+            self.createtempfile()
+            return self
+
+        def __exit__(self, type, value, traceback):
+            self.closetempfile()
+
+        def closetempfile(self):
+            try:
+                if self.file is not None:
+                    self.file.close()
+            finally:
+                self.fd = None
+                self.file = None
+                if self.__autodelete and self.filename is not None and \
+                        _os.path.exists(self.filename):
+                    try:
+                        _os.unlink(self.filename)
+                    finally:
+                        self.filename = None
+
+        def copyto(self, fileto):
+            _shutil.copy(self.filename, fileto)
+
+        def createtempfile(self, mode="w+b"):
+            self.fd, self.filename = _tempfile.mkstemp(prefix=self.__prefix)
+            self.file = _os.fdopen(self.fd, mode)
+            return self
+
+    def __init__(self, filename):
+        self.filename = filename
+
+    def getfilesegment(self):
+        with open(self.filename, "rb") as xginfile:
+            # Extract the uncompressed Game Data Header (GDH)
+            # Note: MS Windows Vista feature
+            gdfheader = \
+                    _xgstruct.GameDataFormatHdrRecord().fromstream(xginfile)
+            if gdfheader is None:
+                raise Error("Not a game data format file", self.filename)
+            
+            # Extract the Game Format Header to a temporary file
+            with Import.Segment(type=Import.Segment.GDF_HDR) as segment:
+                xginfile.seek(0)
+                block = xginfile.read(gdfheader.HeaderSize)
+                segment.file.write(block)
+                segment.file.flush()
+                yield segment
+
+            # Extract the uncompressed thumbnail JPEG from the GDF hdr
+            if (gdfheader.ThumbnailSize > 0):
+                with Import.Segment(type=Import.Segment.GDF_IMAGE) as segment:
+                    xginfile.seek(gdfheader.ThumbnailOffset, _os.SEEK_CUR)
+                    imgbuf = xginfile.read(gdfheader.ThumbnailSize)
+                    segment.file.write(imgbuf)
+                    segment.file.flush()
+                    yield segment
+
+            # Retrieve an archive object from the stream
+            archiveobj = _xgzarc.ZlibArchive(xginfile)
+
+            # Process all the files in the archive
+            for filerec in archiveobj.arcregistry:
+
+                # Retrieve the archive file to a temporary file
+                segment_file, seg_filename = archiveobj.getarchivefile(filerec)
+
+                # Create a file segment object to passback to the caller
+                xg_filetype = Import.Segment.XG_FILEMAP[filerec.name]
+                xg_filesegment = Import.Segment(type=xg_filetype,
+                                                delete=False)
+                xg_filesegment.filename = seg_filename
+                xg_filesegment.fd = segment_file
+
+                # If we are looking at the game info file then check 
+                # the magic number to ensure it is valid
+                if xg_filetype == Import.Segment.XG_GAMEFILE:
+                    segment_file.seek(Import.Segment.XG_GAMEHDR_LEN)
+                    magicStr = bytearray(segment_file.read(4)).decode('ascii')
+                    if magicStr != 'DMLI':
+                        raise Error("Not a valid XG gamefile", self.filename)
+
+                yield xg_filesegment
+
+                segment_file.close()
+                _os.unlink(seg_filename)
+
+        return
+
+
+class Error(Exception):
+
+    def __init__(self, error, filename):
+        self.value = "XG Import Error processing '%s': %s" % \
+                     (filename, str(error))
+        self.error = error
+        self.filename = filename
+
+    def __str__(self):
+        return repr(self.value)
+
+
+if __name__ == '__main__':
+    pass