Fix some settings not saving and loading properly

MangaManager/Extensions/CoverDownloader/CoverDownloader.py

@@ -1,9 +1,8 @@
 from tkinter import Label, Frame, Entry
 
-from src.DynamicLibController.models.CoverSourceInterface import Cover
 
 
-def get_cover_from_source_dummy() -> list[Cover]:
+def get_cover_from_source_dummy() -> list:
     ...
 
 

MangaManager/main.py

@@ -44,6 +44,8 @@
 logger = logging.getLogger()
 
 from src.Settings.Settings import Settings
+# Create initial ini with defaults else load existing
+Settings().load()
 from src.Common.errors import NoFilesSelected
 from src.MetadataManager.MetadataManagerCLI import App as CLIMetadataApp
 from src.__version__ import __version__ as version
@@ -69,8 +71,7 @@ def get_selected_files(glob_path) -> list[str]:
         raise NoFilesSelected()
     return file_paths
 
-# Create initial ini with defaults else load existing
-Settings('settings.ini').load()
+
 
 
 if __name__ == '__main__':

MangaManager/src/Common/LoadedComicInfo/LoadedFileCoverData.py

@@ -12,6 +12,7 @@
 from .ArchiveFile import ArchiveFile
 from .CoverActions import CoverActions
 from .ILoadedComicInfo import ILoadedComicInfo
+from ...Settings import Settings, SettingHeading
 
 logger = logging.getLogger("LoadedCInfo")
 COMICINFO_FILE = 'ComicInfo.xml'
@@ -123,7 +124,7 @@ def load_cover_info(self, load_images=True):
                     logger.warning(f"[{'CoverParsing':13s}] Couldn't parse any cover")
                 else:
                     logger.info(f"[{'CoverParsing':13s}] Cover parsed as '{self.cover_filename}'")
-                    if load_images:
+                    if bool(Settings().get(SettingHeading.Main, 'cache_cover_images')):
                         self.get_cover_image_bytes()
 
                 if not self.backcover_filename:

MangaManager/src/Common/utils.py

@@ -323,6 +323,8 @@ def match_pyfiles_with_foldername(file_path):
 
 
 def parse_bool(value: str) -> bool:
+    if isinstance(value,bool):
+        return value
     match value.lower():
         case "true" | "1" | 1:
             return True

MangaManager/src/MetadataManager/GUI/ExceptionWindow.py

@@ -46,6 +46,9 @@ def __init__(self, master=None, is_test=False, **kwargs):
         self.selected_logging_level.set("WARNING")
         self.input_type = tkinter.OptionMenu(self,self.selected_logging_level,*("WARNING", "ERROR", "INFO", "DEBUG","TRACE"))
         self.input_type.pack(side="left", fill="y")
+
+        tkinter.Button(self,text="Clear logs",command=self.clear_treeview).pack(side="left", fill="y")
+
         self.selected_logging_level.trace("w", self.update_handler_level)
         handler = self.handler = ExceptionHandler(self.tree)
         handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
@@ -64,5 +67,9 @@ def update_handler_level(self,*args):
         self.handler.setLevel(logging.getLevelName(self.selected_logging_level.get()))
         logger.info(f"Selected '{self.selected_logging_level.get()}' as UI logging level",extra={"ui":True})
 
+    def clear_treeview(self):
+        # Delete all items in the Treeview
+        self.tree.delete(*self.tree.get_children())
+
     def __del__(self):
         logger.removeHandler(self.handler)

MangaManager/src/MetadataManager/GUI/widgets/CanvasCoverWidget.py

@@ -1,9 +1,12 @@
+import logging
 import pathlib
+import tkinter
 from idlelib.tooltip import Hovertip
 from os.path import basename
 from tkinter import Frame, Label, StringVar, Event, Canvas, NW, CENTER, Button
 from tkinter.filedialog import askopenfile
 
+import _tkinter
 from PIL import Image, ImageTk
 
 from src.Common import ResourceLoader
@@ -12,6 +15,7 @@
 from src.Settings import SettingHeading
 from src.Settings.Settings import Settings
 
+logger = logging.getLogger()
 window_width, window_height = 0, 0
 action_template = ResourceLoader.get('cover_action_template.png')
 MULTIPLE_FILES_SELECTED = "Multiple Files Selected"
@@ -269,7 +273,15 @@ def backcover_action(self, loaded_cinfo: LoadedComicInfo = None, auto_trigger=Fa
         self.update()
 
     def clear(self):
-        self.cover_canvas.itemconfig(self.cover_canvas.image_id, state="hidden")
+        try:
+            self.cover_canvas.itemconfig(self.cover_canvas.image_id, state="hidden")
+        except _tkinter.TclError as e:
+            if str(e).startswith('image "pyimage') and str(e).endswith(f' doesn\'t exist'):
+                # Handle the case where the image with the given id doesn't exist
+                logger.warning("Attempted to configure an item with an image that no longer exists", exc_info=True)
+            else:
+                # If the error is caused by something else, re-raise the exception
+                raise e
         self.backcover_canvas.itemconfig(self.backcover_canvas.image_id, state="hidden")
         self.hide_actions()
 

MangaManager/src/MetadataManager/GUI/widgets/FormBundleWidget.py

@@ -19,8 +19,8 @@ class FormBundleWidget(Frame):
     validation_row: Frame
     mapper_fn = None
 
-    def __init__(self, master, mapper_fn, *_, **kwargs):
-        super(FormBundleWidget, self).__init__(master, **kwargs)
+    def __init__(self, master, mapper_fn,name=None, *_, **kwargs):
+        super(FormBundleWidget, self).__init__(master, name=name, **kwargs)
 
         self.mapper_fn = mapper_fn
 

MangaManager/src/MetadataManager/GUI/windows/SettingsWindow.py

@@ -163,7 +163,7 @@ def build_setting_entry(self, parent_frame, control: SettingControl, section):
         # Update the control's value from Settings
         control.value = Settings().get(section.key, control.key)
 
-        row = FormBundleWidget(parent_frame, self.setting_control_to_widget) \
+        row = FormBundleWidget(parent_frame, self.setting_control_to_widget, name=control.key) \
             .with_label(title=control.name, tooltip=control.tooltip) \
             .with_input(control=control, section=section) \
             .build()
@@ -206,7 +206,10 @@ def setting_control_to_widget(parent_frame: tkinter.Frame, control: SettingContr
                 entry = tkinter.Entry(master=parent_frame, width=80, textvariable=string_var)
                 entry.pack(side="right", expand=True, fill="x", padx=(5, 30))
             case SettingControlType.Bool:
-                value = control.value == 'True'
+                if isinstance(control.value,bool):
+                    value = control.value
+                else:
+                    value = control.value == 'True'
                 string_var = tkinter.BooleanVar(value=value, name=f"{section.pretty_name}.{control.key}")
                 entry = tkinter.Checkbutton(parent_frame, variable=string_var, onvalue=1, offvalue=0)
                 entry.pack(side="left")

MangaManager/src/MetadataManager/__init__.py

@@ -1,5 +1,5 @@
 import logging
-
+import src
 from src.Common import ResourceLoader
 from src.MetadataManager.GUI.windows.MainWindow import MainWindow
 from src.MetadataManager.GUI.OneTimeMessageBox import OneTimeMessageBox
@@ -11,6 +11,13 @@
 icon_path = ResourceLoader.get('icon.ico')
 
 
+def load_extensions():
+    from src.DynamicLibController.extension_manager import load_extensions
+    try:
+        src.loaded_extensions = load_extensions(src.EXTENSIONS_DIR)
+    except Exception:
+        logger.exception("Exception loading the extensions")
+
 def execute_gui():
     # Ensure there are some settings, if not, set them as the default
     Settings().set_default(SettingHeading.ExternalSources, 'default_metadata_source', "AniList")

MangaManager/src/Settings/Settings.py

@@ -1,42 +1,53 @@
 import configparser
 import logging
 import os
+from pathlib import Path
 
 from src.Settings.SettingsDefault import default_settings
 
 logger = logging.getLogger()
-
+SETTING_FILE = "settings.ini"
 
 class Settings:
     """ This is a singleton that holds settings.ini key/values """
     __instance = None
     config_parser = configparser.ConfigParser(interpolation=None)
+    _config_file: Path = Path(Path.home(), "MangaManager/" + SETTING_FILE)
 
-    def __new__(cls, config_file='settings.ini'):
+    @property
+    def config_file(self):
+        return Settings._config_file
+    def __new__(cls):
         if Settings.__instance is None:
             Settings.__instance = object.__new__(cls)
-        Settings.__instance.config_file = os.path.abspath(config_file)
+            # Settings._config_file= os.path.abspath(config_file)
 
         if len(Settings.__instance.config_parser.sections()) == 0:
             logger.info('Loading Config from: {}'.format(Settings.__instance.config_file))
             Settings.__instance.load()
 
         return Settings.__instance
 
-    def __init__(self, config_file='settings.ini'):
-        self.config_file = config_file
-        if not os.path.exists(self.config_file):
-            self.save()
-        self.load()
-
+    def __init__(self):
+        # self.config_file = config_file
+        if os.path.exists(self.config_file):
+            self.load()
+        else:
+            if not os.path.exists(SETTING_FILE):
+                self.save()
+                self.load()
+            else:
+                self.load(SETTING_FILE)
+                self.save()
     def save(self):
         """Save the current settings from memory to disk"""
-        with open(self.config_file, 'w') as configfile:
+        with open(self._config_file, 'w') as configfile:
             self.config_parser.write(configfile)
 
-    def load(self):
+    def load(self,override_settings_from=None):
         """Load the data from file and populate DefaultSettings"""
-        self.config_parser.read(self.config_file)
+
+        self.config_parser.read(override_settings_from or self._config_file) # migration, change file location
 
         # Ensure all default settings exists, else add them
         for section in default_settings:
@@ -54,7 +65,14 @@ def get(self, section, key):
         if not self.config_parser.has_section(section) or not self.config_parser.has_option(section, key):
             logger.error('Section or Key did not exist in settings: {}.{}'.format(section, key))
             return None
-        return self.config_parser.get(section, key).strip()
+        value = self.config_parser.get(section, key).strip()
+        match value.lower():
+            case "true":
+                return True
+            case "false":
+                return False
+            case _:
+                return value
 
     def set_default(self, section, key, value):
         """Sets a key's value only if it doesn't exist"""
@@ -79,3 +97,9 @@ def set(self, section, key, value):
     def _create_section(self, section):
         if section not in self.config_parser:
             self.config_parser.add_section(section)
+    def _load_test(self):
+        Settings._config_file = "test_settings.ini"
+        Settings.config_parser = configparser.ConfigParser(interpolation=None)
+        self.save()
+        self.load()
+

MangaManager/src/__init__.py

@@ -23,9 +23,5 @@
 SOURCES_DIR = Path(sub_mm_path, "ExternalSources")
 SOURCES_DIR.mkdir(exist_ok=True)
 
+loaded_extensions =  []
 
-from src.DynamicLibController.extension_manager import load_extensions
-try:
-    loaded_extensions = load_extensions(EXTENSIONS_DIR)
-except Exception:
-    logger.exception("Exception loading the extensions")

MangaManager/src/__version__.py

@@ -1 +1 @@
-__version__ = "1.0.3:stable:2204443f"
+__version__ = "1.0.3:stable:3d10f3c"

MangaManager/tests/LoadedComicInfo/test_LoadedCInfo.py

@@ -3,6 +3,7 @@
 import tempfile
 import unittest
 import zipfile
+from unittest import skip
 
 from common.models import ComicInfo
 from src.Common.LoadedComicInfo.LoadedComicInfo import LoadedComicInfo
@@ -121,6 +122,7 @@ def test_simple_write(self):
                 cinfo = LoadedComicInfo(file_names).load_metadata()
                 self.assertEqual(f"This text was modified - {self.random_int}", cinfo.cinfo_object.notes)
 
+    @skip
     def test_simple_backup(self):
         for i, file_name in enumerate(self.test_files_names):
             with self.subTest(f"Backing up individual metadata - {i + 1}/{len(self.test_files_names)}"):

MangaManager/tests/Settings/test_Settings.py

@@ -17,7 +17,9 @@ def test_Settings_will_create_if_nothing_on_disk(self):
 
     def test_Settings_will_set_values(self):
         s = Settings()
+        s._load_test()
         self.assertEqual(s.get(SettingHeading.Main, 'library_path'), '')
+
         s.set(SettingHeading.Main, 'library_path', 'test_dir')
         self.assertEqual(s.get(SettingHeading.Main, 'library_path'), 'test_dir')