config-cli-gui 0.1.9__tar.gz → 0.2.0__tar.gz

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/HISTORY.md

@@ -4,6 +4,23 @@ Changelog
 
 (unreleased)
 ------------
+- #9 fix posix path issue. [Paul Magister]
+- #9 fix posix path issue. [Paul Magister]
+
+
+0.1.10 (2025-11-13)
+-------------------
+- Docs: Update HISTORY.md for release 0.1.10. [Paul Magister]
+- #9 unittests docs.py. [Paul Magister]
+- #9 unittests config.py. [Paul Magister]
+- #9 roll back to .value usage to be type save: documentation. [Paul
+  Magister]
+- #9 roll back to .value usage to be type save. [Paul Magister]
+
+
+0.1.9 (2025-11-12)
+------------------
+- Docs: Update HISTORY.md for release 0.1.9. [Paul Magister]
 - #8 fix bug with .value. [Paul Magister]
 
 

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: config-cli-gui
-Version: 0.1.9
+Version: 0.2.0
 Summary: Feature-rich Python project template for config-cli-gui.
 Author: pamagister
 Requires-Python: <3.12,>=3.10

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/README.md

@@ -58,11 +58,16 @@ Start by defining your application's configuration parameters in a central `conf
 ```python
 # my_project/config_example.py
 
+from datetime import datetime
+from pathlib import Path
+
 from config_cli_gui.config import (
+    Color,
     ConfigCategory,
     ConfigManager,
     ConfigParameter,
 )
+from config_cli_gui.docs import DocumentationGenerator
 
 
 class CliConfig(ConfigCategory):
@@ -74,55 +79,61 @@ class CliConfig(ConfigCategory):
     # Positional argument
     input: ConfigParameter = ConfigParameter(
         name="input",
-        default="",
+        value="",
         help="Path to input (file or folder)",
         required=True,
         is_cli=True,
     )
 
-    min_dist: ConfigParameter = ConfigParameter(
-        name="min_dist",
-        default=20,
-        help="Maximum distance between two waypoints",
+    # Optional CLI arguments
+    output: ConfigParameter = ConfigParameter(
+        name="output",
+        value="",
+        help="Path to output destination",
         is_cli=True,
     )
 
-    extract_waypoints: ConfigParameter = ConfigParameter(
-        name="extract_waypoints",
-        default=True,
-        help="Extract starting points of each track as waypoint",
+    min_dist: ConfigParameter = ConfigParameter(
+        name="min_dist",
+        value=20,
+        help="Maximum distance between two waypoints",
         is_cli=True,
     )
 
 
-class AppConfig(ConfigCategory):
-    """Application-specific configuration parameters."""
-
+class MiscConfig(ConfigCategory):
     def get_category_name(self) -> str:
-        return "app"
+        return "misc"
+
+    some_file: ConfigParameter = ConfigParameter(
+        name="some_file",
+        value=Path("some_file.txt"),
+        help="Path to the file to use",
+    )
 
-    log_level: ConfigParameter = ConfigParameter(
-        name="log_level",
-        default="INFO",
-        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
-        help="Logging level for the application",
+    some_color: ConfigParameter = ConfigParameter(
+        name="some_color",
+        value=Color(255, 0, 0),
+        help="Color setting for the application",
     )
 
-    log_file_max_size: ConfigParameter = ConfigParameter(
-        name="log_file_max_size",
-        default=10,
-        help="Maximum log file size in MB before rotation",
+    some_date: ConfigParameter = ConfigParameter(
+        name="some_date",
+        value=datetime.now(),
+        help="Date setting for the application",
     )
 
 
 class ProjectConfigManager(ConfigManager):  # Inherit from ConfigManager
     """Main configuration manager that handles all parameter categories."""
 
-    categories = (CliConfig(), AppConfig())
+    cli: CliConfig
+    misc: MiscConfig
 
     def __init__(self, config_file: str | None = None, **kwargs):
         """Initialize the configuration manager with all parameter categories."""
-        super().__init__(self.categories, config_file, **kwargs)
+        categories = (CliConfig(), MiscConfig())
+        super().__init__(categories, config_file, **kwargs)
 
 
 ```

config_cli_gui-0.2.0/config.yaml

@@ -0,0 +1,48 @@
+app:
+  # Date format to use | type=str, default=%Y-%m-%d
+  date_format: '%Y-%m-%d'
+  # Enable logging to console | type=bool, default=True
+  enable_console_logging: true
+  # Enable logging to file | type=bool, default=True
+  enable_file_logging: true
+  # Number of backup log files to keep | type=int, default=5
+  log_backup_count: 5
+  # Maximum log file size in MB before rotation | type=int, default=10
+  log_file_max_size: 10
+  # Log message format style | type=str, default=detailed
+  log_format: detailed
+  # Logging level for the application | type=str, default=INFO
+  log_level: INFO
+  # Maximum number of worker threads | type=int, default=4
+  max_workers: 4
+cli:
+  # Include elevation data in waypoints | type=bool, default=True [CLI]
+  elevation: true
+  # Extract starting points of each track as waypoint | type=bool, default=True [CLI]
+  extract_waypoints: true
+  # Path to input (file or folder) | type=str, default= [CLI]
+  input: ''
+  # Maximum distance between two waypoints | type=int, default=20 [CLI]
+  min_dist: 20
+  # Path to output destination | type=str, default= [CLI]
+  output: ''
+gui:
+  # Automatically scroll to the newest log entries | type=bool, default=True
+  auto_scroll_log: true
+  # Height of the log window in pixels | type=int, default=200
+  log_window_height: 200
+  # Maximum number of log lines to keep in GUI | type=int, default=1000
+  max_log_lines: 1000
+  # GUI theme setting | type=str, default=light
+  theme: light
+  # Default window height | type=int, default=600
+  window_height: 600
+  # Default window width | type=int, default=800
+  window_width: 800
+misc:
+  # Color setting for the application | type=Color, default=#ff0000
+  some_color: '#ff0000'
+  # Date setting for the application | type=datetime, default=2025-11-13 22:49:38.801511
+  some_date: '2025-11-13T22:49:38.801511'
+  # Path to the file to use | type=PosixPath, default=some_file.txt
+  some_file: some_file.txt

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/docs/usage/config.md

@@ -43,5 +43,5 @@ The parameters in the cli category can be accessed via the command line interfac
 |------------|-----------|-----------------------------------|-----------------------------------------------------|---------|
 | some_file  | PosixPath | Path to the file to use           | PosixPath('some_file.txt')                          | -       |
 | some_color | Color     | Color setting for the application | Color(255, 0, 0)                                    | -       |
-| some_date  | datetime  | Date setting for the application  | datetime.datetime(2025, 11, 12, 22, 24, 14, 121460) | -       |
+| some_date  | datetime  | Date setting for the application  | datetime.datetime(2025, 11, 13, 22, 49, 38, 801511) | -       |
 

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/src/config_cli_gui/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.9'
-__version_tuple__ = version_tuple = (0, 1, 9)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
 
-__commit_id__ = commit_id = 'gc9df12403'
+__commit_id__ = commit_id = 'gd5e29e239'

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/src/config_cli_gui/cli.py

@@ -130,7 +130,7 @@ class CliGenerator:
                 updated_config.add_category(name, category)
 
             # Apply overrides again after copying categories
-            updated_config._apply_kwargs(cli_overrides)
+            updated_config.apply_overrides(cli_overrides)
 
             # Try to get logger if logging is configured
             try:

config_cli_gui-0.2.0/src/config_cli_gui/config.py

@@ -0,0 +1,245 @@
+import json
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel
+
+
+class Color:
+    """Simple color class for RGB values."""
+
+    def __init__(self, r: int = 0, g: int = 0, b: int = 0):
+        self.r = max(0, min(255, r))
+        self.g = max(0, min(255, g))
+        self.b = max(0, min(255, b))
+
+    def to_list(self) -> list[int]:
+        return [self.r, self.g, self.b]
+
+    def to_hex(self) -> str:
+        return f"#{self.r:02x}{self.g:02x}{self.b:02x}"
+
+    @classmethod
+    def from_list(cls, rgb_list: list[int | str]) -> "Color":
+        if len(rgb_list) >= 3:
+            return cls(int(rgb_list[0]), int(rgb_list[1]), int(rgb_list[2]))
+        return cls()
+
+    @classmethod
+    def from_hex(cls, hex_color: str) -> "Color":
+        hex_color = hex_color.lstrip("#")
+        if len(hex_color) == 6:
+            return cls(
+                int(hex_color[0:2], 16),
+                int(hex_color[2:4], 16),
+                int(hex_color[4:6], 16),
+            )
+        return cls()
+
+    def __str__(self):
+        return self.to_hex()
+
+    def __repr__(self):
+        return f"Color({self.r}, {self.g}, {self.b})"
+
+
+@dataclass
+class ConfigParameter:
+    """Represents a single configuration parameter with metadata."""
+
+    name: str
+    value: Any
+    choices: list | tuple | None = None
+    help: str = ""
+    cli_arg: str | None = None
+    required: bool = False
+    is_cli: bool = False
+    category: str = "general"
+
+    def __post_init__(self):
+        if self.is_cli and self.cli_arg is None and not self.required:
+            self.cli_arg = f"--{self.name}"
+        if isinstance(self.value, bool) and self.choices is None:
+            self.choices = [True, False]
+
+    @property
+    def type_(self) -> type:
+        """Return the Python type of this parameter’s value."""
+        return type(self.value)
+
+
+class ConfigCategory(BaseModel, ABC):
+    """Base class for configuration categories."""
+
+    @abstractmethod
+    def get_category_name(self) -> str:
+        pass
+
+    def get_parameters(self) -> list[ConfigParameter]:
+        """Return ConfigParameter instances that are actual instance attributes."""
+        params = []
+
+        for value in vars(self).values():  # faster, only instance attrs
+            if isinstance(value, ConfigParameter):
+                value.category = self.get_category_name()
+                params.append(value)
+
+        return params
+
+
+class ConfigManager:
+    """Generic configuration manager handling multiple configuration categories."""
+
+    def __init__(
+        self,
+        categories: tuple[ConfigCategory, ...],
+        config_file: str | None = None,
+        **overrides: Any,
+    ):
+        self._categories: dict[str, ConfigCategory] = {}
+
+        # Register categories and expose them as attributes
+        for category in categories:
+            if not isinstance(category, ConfigCategory):
+                raise TypeError(f"Expected ConfigCategory instance, got {type(category)}")
+            self.add_category(category.get_category_name(), category)
+
+        # Load configuration from file if provided
+        if config_file:
+            self.load_from_file(config_file)
+
+        # Apply overrides (category__param=value)
+        self.apply_overrides(overrides)
+
+    def add_category(self, name: str, category: ConfigCategory):
+        self._categories[name] = category
+        setattr(self, name, category)
+
+    def get_category(self, name: str) -> ConfigCategory | None:
+        return self._categories.get(name)
+
+    def apply_overrides(self, overrides: dict[str, Any]):
+        """Apply keyword overrides in format category__param=value."""
+        for key, value in overrides.items():
+            if "__" not in key:
+                continue
+            category_name, param_name = key.split("__", 1)
+            category = self._categories.get(category_name)
+            if category and hasattr(category, param_name):
+                param = getattr(category, param_name)
+                if isinstance(param, ConfigParameter):
+                    param.value = value
+                else:
+                    setattr(category, param_name, value)
+
+    def load_from_file(self, config_file: str):
+        path = Path(config_file)
+        if not path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_file}")
+
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) if path.suffix in [".yml", ".yaml"] else json.load(f)
+
+        self._apply_config_data(data)
+
+    def _apply_config_data(self, data: dict):
+        for category_name, category_data in data.items():
+            category = self._categories.get(category_name)
+            if not category:
+                continue
+            for param_name, param_value in category_data.items():
+                param: ConfigParameter = getattr(category, param_name, None)
+                if not isinstance(param, ConfigParameter):
+                    continue
+
+                # Type conversions
+                if isinstance(param.value, Color) and isinstance(param_value, list):
+                    param_value = Color.from_list(param_value)
+                if isinstance(param.value, Color) and isinstance(param_value, str):
+                    param_value = Color.from_hex(param_value)
+                elif isinstance(param.value, Path):
+                    param_value = Path(param_value)
+                elif isinstance(param.value, datetime):
+                    param_value = datetime.fromisoformat(param_value)
+
+                param.value = param_value
+
+    def save_to_file(self, config_file: str, format_: str = "auto"):
+        path = Path(config_file)
+        data = self.to_dict()
+
+        if format_ == "auto":
+            format_ = "yaml" if path.suffix in [".yml", ".yaml"] else "json"
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            if format_ == "yaml":
+                yaml.dump(data, f, indent=2)
+            else:
+                json.dump(data, f, indent=2)
+
+        if format_ == "yaml":
+            self._append_comments_to_yaml(path)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert all configuration categories to a dictionary of plain values."""
+        result: dict[str, dict[str, Any]] = {}
+        for category in self._categories.values():
+            category_name = category.get_category_name()
+            result[category_name] = {}
+            for param in category.get_parameters():
+                val = getattr(category, param.name).value
+                if isinstance(val, Color):
+                    val = val.to_hex()
+                elif isinstance(val, Path):
+                    val = str(val.as_posix())
+                elif isinstance(val, datetime):
+                    val = val.isoformat()
+                result[category_name][param.name] = val
+        return result
+
+    def get_all_parameters(self) -> list[ConfigParameter]:
+        return [p for c in self._categories.values() for p in c.get_parameters()]
+
+    def get_cli_parameters(self) -> list[ConfigParameter]:
+        return [p for p in self.get_all_parameters() if p.is_cli]
+
+    def _append_comments_to_yaml(self, path: Path):
+        """Append helpful metadata comments to the YAML file."""
+        lines = path.read_text(encoding="utf-8").splitlines()
+        new_lines = []
+        all_params = {p.name: p for p in self.get_all_parameters()}
+        current_category = None
+
+        for line in lines:
+            stripped = line.strip()
+            if (
+                stripped.endswith(":")
+                and not stripped.startswith("#")
+                and line.startswith(stripped)
+            ):
+                current_category = stripped[:-1]
+                new_lines.append(line)
+                continue
+
+            parts = stripped.split(":", 1)
+            if len(parts) > 1:
+                param_name = parts[0].strip()
+                if param_name in all_params:
+                    param = all_params[param_name]
+                    if current_category and param.category == current_category:
+                        indent = " " * (len(line) - len(stripped))
+                        comment = (
+                            f"{indent}# {param.help} | "
+                            f"type={param.type_.__name__}, default={param.value}"
+                            f"{' [CLI]' if param.is_cli else ''}"
+                        )
+                        new_lines.append(comment)
+
+            new_lines.append(line)
+
+        path.write_text("\n".join(new_lines), encoding="utf-8")

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/src/config_cli_gui/gui.py

@@ -258,18 +258,19 @@ class GenericSettingsDialog:
         canvas.configure(yscrollcommand=scrollbar.set)
 
         # Add parameters
-        self._add_category_parameters(scrollable_frame, category_name, category)
+        self._add_category_parameters(scrollable_frame, category)
 
         canvas.pack(side="left", fill="both", expand=True)
         scrollbar.pack(side="right", fill="y")
 
-    def _add_category_parameters(self, parent, category_name: str, category: ConfigCategory):
+    def _add_category_parameters(self, parent, category: ConfigCategory):
         """Add parameter widgets for a specific category."""
         row = 0
+        category_name: str = category.get_category_name()
         parameters = category.get_parameters()
 
         for param in parameters:
-            param.value = getattr(category, param.name)
+            param.value = getattr(category, param.name).value
             if param.required:
                 # Skip required parameters as they are not configurable in GUI
                 continue
@@ -391,8 +392,8 @@ class GenericSettingsDialog:
         entry = ttk.Entry(frame, textvariable=var, width=10)
         entry.pack(side=tk.LEFT)
 
-        color_display = tk.Label(frame, width=7, bg=color_value.to_hex())
-        color_display.pack(side=tk.LEFT, padx=(5, 0))
+        color_display = tk.Label(frame, width=8, bg=color_value.to_hex())
+        color_display.pack(side=tk.LEFT, padx=(8, 2))
 
         def pick_color():
             color = colorchooser.askcolor(color=var.get())
@@ -491,35 +492,35 @@ class GenericSettingsDialog:
                 # Parse value based on parameter type
                 category_name, param_name = key.split("__", 1)
                 category = self.config_manager.get_category(category_name)
-                param = getattr(category, param_name)
+                param_value = getattr(category, param_name).value
 
                 # Convert value to appropriate type
-                if type(param) == bool:
+                if type(param_value) == bool:
                     overrides[key] = value
-                elif type(param) == Path:
+                elif type(param_value) == Path:
                     overrides[key] = Path(value)
-                elif type(param) == Color:
+                elif type(param_value) == Color:
                     overrides[key] = Color.from_hex(value)
-                elif type(param) == datetime:
+                elif type(param_value) == datetime:
                     overrides[key] = datetime.strptime(value, "%Y-%m-%d %H:%M")
-                elif type(param) in (list, tuple):
+                elif type(param_value) in (list, tuple):
                     # Parse comma-separated values
                     items = [item.strip() for item in value.split(",") if item.strip()]
-                    overrides[key] = type(param)(items)
-                elif type(param) == dict:
+                    overrides[key] = type(param_value)(items)
+                elif type(param_value) == dict:
                     # Parse JSON format
                     import json
 
                     overrides[key] = json.loads(value)
-                elif type(param) == int:
+                elif type(param_value) == int:
                     overrides[key] = int(value)
-                elif type(param) == float:
+                elif type(param_value) == float:
                     overrides[key] = float(value)
                 else:
                     overrides[key] = value
 
             # Apply overrides to config manager
-            self.config_manager._apply_kwargs(overrides)
+            self.config_manager.apply_overrides(overrides)
 
             # Save to file
             self.config_manager.save_to_file(self.config_file)

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/src/config_cli_gui.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: config-cli-gui
-Version: 0.1.9
+Version: 0.2.0
 Summary: Feature-rich Python project template for config-cli-gui.
 Author: pamagister
 Requires-Python: <3.12,>=3.10

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/src/config_cli_gui.egg-info/SOURCES.txt

@@ -54,6 +54,8 @@ src/config_cli_gui.egg-info/entry_points.txt
 src/config_cli_gui.egg-info/requires.txt
 src/config_cli_gui.egg-info/top_level.txt
 tests/__init__.py
+tests/test_config_manager.py
+tests/test_docs.py
 tests/test_generic_cli.py
 tests/example_project/__init__.py
 tests/example_project/__main__.py

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/tests/example_project/core/logging.py

@@ -53,7 +53,7 @@ class LoggerManager:
         self.logger.handlers.clear()
 
         # Set log level from config
-        log_level = getattr(logging, self.config.app.log_level.upper())
+        log_level = getattr(logging, self.config.app.log_level.value.upper())
         self.logger.setLevel(log_level)
 
         # Create formatters
@@ -142,15 +142,15 @@ class LoggerManager:
         self.logger.setLevel(log_level)
 
         # Update config
-        self.config.get_category("app").log_level = level.upper()
+        self.config.app.log_level.value = level.upper()
 
     def log_config_summary(self):
         """Log current configuration summary."""
         self.logger.info("=== Configuration Summary ===")
-        self.logger.info(f"Log level: {self.config.app.log_level}")
-        self.logger.info(f"Input: {self.config.cli.input}")
-        self.logger.info(f"Output: {self.config.get_category('cli').output}")
-        self.logger.info(f"Max workers: {self.config.app.max_workers}")
+        self.logger.info(f"Log level: {self.config.app.log_level.value}")
+        self.logger.info(f"Input: {self.config.cli.input.value}")
+        self.logger.info(f"Output: {self.config.cli.output.value}")
+        self.logger.info(f"Max workers: {self.config.app.max_workers.value}")
         self.logger.info("==============================")
 
 

config_cli_gui-0.2.0/tests/example_project/gui/config.yaml

@@ -0,0 +1,48 @@
+app:
+  # Date format to use | type=str, default=%d-%m-%YYYY
+  date_format: '%d-%m-%YYYY'
+  # Enable logging to console | type=bool, default=True
+  enable_console_logging: true
+  # Enable logging to file | type=bool, default=True
+  enable_file_logging: true
+  # Number of backup log files to keep | type=int, default=50
+  log_backup_count: 50
+  # Maximum log file size in MB before rotation | type=int, default=10
+  log_file_max_size: 10
+  # Log message format style | type=str, default=detailed
+  log_format: detailed
+  # Logging level for the application | type=str, default=INFO
+  log_level: INFO
+  # Maximum number of worker threads | type=int, default=4
+  max_workers: 4
+cli:
+  # Include elevation data in waypoints | type=bool, default=True [CLI]
+  elevation: true
+  # Extract starting points of each track as waypoint | type=bool, default=True [CLI]
+  extract_waypoints: true
+  # Path to input (file or folder) | type=str, default= [CLI]
+  input: ''
+  # Maximum distance between two waypoints | type=int, default=2480 [CLI]
+  min_dist: 2480
+  # Path to output destination | type=str, default=test [CLI]
+  output: test
+gui:
+  # Automatically scroll to the newest log entries | type=bool, default=True
+  auto_scroll_log: true
+  # Height of the log window in pixels | type=int, default=200
+  log_window_height: 200
+  # Maximum number of log lines to keep in GUI | type=int, default=1000
+  max_log_lines: 1000
+  # GUI theme setting | type=str, default=light
+  theme: light
+  # Default window height | type=int, default=600
+  window_height: 600
+  # Default window width | type=int, default=800
+  window_width: 800
+misc:
+  # Color setting for the application | type=Color, default=#c64800
+  some_color: '#c64800'
+  # Date setting for the application | type=datetime, default=2025-11-12 17:10:00
+  some_date: '2025-11-12T17:10:00'
+  # Path to the file to use | type=str, default=some_file.txt
+  some_file: some_file.txt

{config_cli_gui-0.1.9 → config_cli_gui-0.2.0}/tests/example_project/gui/gui_example.py

@@ -241,7 +241,7 @@ class MainGui:
 
         # Log level selector
         ttk.Label(log_controls, text="Log Level:").pack(side=tk.LEFT, padx=(10, 5))
-        self.log_level_var = tk.StringVar(value=self._config.app.log_level)
+        self.log_level_var = tk.StringVar(value=self._config.app.log_level.value)
         log_level_combo = ttk.Combobox(
             log_controls,
             textvariable=self.log_level_var,
@@ -454,10 +454,10 @@ class MainGui:
             # Create and run project
             project = BaseGPXProcessor(
                 files_to_process,  # Pass selected files
-                self._config.cli.output,
-                self._config.cli.min_dist,
-                self._config.app.date_format,
-                self._config.cli.elevation,
+                self._config.cli.output.value,
+                self._config.cli.min_dist.value,
+                self._config.app.date_format.value,
+                self._config.cli.elevation.value,
                 self.logger,
             )
             # implement switch case for different processing modes
@@ -504,7 +504,7 @@ class MainGui:
         if dialog.result == "ok":
             self.logger.info("Settings updated successfully")
             # Update log level selector if it changed
-            self.log_level_var.set(self._config.app.log_level)
+            self.log_level_var.set(self._config.app.log_level.value)
 
     def _open_help(self):
         """Open help documentation in browser."""