config-cli-gui 0.1.0__tar.gz → 0.1.2__tar.gz

{config_cli_gui-0.1.0 → config_cli_gui-0.1.2}/.idea/runConfigurations/config_generate.xml

@@ -8,12 +8,12 @@
       <env name="PYTHONUNBUFFERED" value="1" />
     </envs>
     <option name="SDK_HOME" value="" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/src/config_cli_gui" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/tests/example_project/config" />
     <option name="IS_MODULE_SDK" value="true" />
     <option name="ADD_CONTENT_ROOTS" value="true" />
     <option name="ADD_SOURCE_ROOTS" value="true" />
     <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
-    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/src/config_cli_gui/config/config.py" />
+    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/tests/example_project/config/config.py" />
     <option name="PARAMETERS" value="" />
     <option name="SHOW_COMMAND_LINE" value="false" />
     <option name="EMULATE_TERMINAL" value="false" />

config_cli_gui-0.1.2/HISTORY.md

@@ -0,0 +1,25 @@
+Changelog
+=========
+
+
+(unreleased)
+------------
+- Feat #3: avoid type_ [Paul Magister]
+- Feat #3: Improved paramter types: [Paul Magister]
+- Feat #3: Improved paramter types: * move example project to tests *
+  remove type_ * add improved widgets to gui_generator.py * separate
+  module for docs_generator.py. [Paul Magister]
+
+
+0.1.0 (2025-06-22)
+------------------
+- Remove unnecessary example files and deps. [Paul Magister]
+- Update README.md from docs/index.md. [github-actions]
+- Fix doc: formatting. [Paul Magister]
+
+
+0.0.2 (2025-06-22)
+------------------
+- Remove _version.py. [Paul Magister]
+
+

{config_cli_gui-0.1.0 → config_cli_gui-0.1.2}/Makefile

@@ -55,38 +55,6 @@ test: lint        ## Run tests and generate coverage report.
 	uv run coverage xml
 	uv run coverage html
 
-.PHONY: build-win
-build-win:    ## Build the Windows executable.
-	echo "Building unified CLI/GUI application"
-	uv run pyinstaller --onefile src/main.py --name config-cli-gui --add-data "config.yaml;." --hidden-import config_cli_gui.cli.cli --hidden-import config_cli_gui.gui.gui
-	rm -rf release
-	mkdir release
-	cp dist/config-cli-gui.exe release
-	cp config.yaml release
-	cp README.md release
-
-.PHONY: build-macos
-build-macos:    ## Build the macOS executable.
-	echo "Building unified CLI/GUI application as executable"
-	uv run pyinstaller --onefile src/main.py --name config-cli-gui --add-data "config.yaml:." --hidden-import config_cli_gui.cli.cli --hidden-import config_cli_gui.gui.gui
-
-	echo "Building unified CLI/GUI application as .app bundle"
-	# --windowed is important to hide the console for GUI mode
-	# The name "TemplateApp" becomes the name of the .app
-	uv run pyinstaller --windowed --name "TemplateApp" src/main.py --add-data "config.yaml:." --hidden-import config_cli_gui.cli.cli --hidden-import config_cli_gui.gui.gui
-
-	# Prepare ZIP file for release
-	rm -rf release
-	mkdir release
-	echo "Copy the CLI/GUI executable"
-	cp dist/config-cli-gui release/
-	echo "Copy the .app bundle (directory) recursively"
-	cp -R "dist/TemplateApp.app" release/
-	echo "Copy configuration and documentation"
-	cp config.yaml release/
-	cp README.md release/
-	echo "Create usage instructions"
-
 .PHONY: watch
 watch:            ## Run tests on every change.
 	ls **/**.py | entr uv run pytest -s -vvv -l --tb=long --maxfail=1 tests/

{config_cli_gui-0.1.0/src/config_cli_gui.egg-info → config_cli_gui-0.1.2}/PKG-INFO

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

config_cli_gui-0.1.2/config.yaml

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

config_cli_gui-0.1.2/docs/getting-started/install.md

@@ -0,0 +1,28 @@
+# Installation
+
+
+## 🐍 PyPI
+
+### Install the package from PyPI
+
+Download from [PyPI](https://pypi.org/):
+
+```bash
+pip install config-cli-gui
+```
+
+## 👩🏼‍💻 Run from source
+
+### Clone the repository
+
+```bash
+git clone
+```
+
+### Install dependencies
+
+```bash
+uv venv
+uv pip install -e .[dev,docs]
+```
+

{config_cli_gui-0.1.0 → config_cli_gui-0.1.2}/docs/usage/cli.md

@@ -26,19 +26,33 @@ python -m app [OPTIONS] input
 python -m app input
 ```
 
-### 2. With min_dist parameter
+### 2. With verbose logging
+
+```bash
+python -m app -v input
+python -m app --verbose input
+```
+
+### 3. With quiet mode
+
+```bash
+python -m app -q input
+python -m app --quiet input
+```
+
+### 4. With min_dist parameter
 
 ```bash
 python -m app --min_dist 20 input
 ```
 
-### 3. With extract_waypoints parameter
+### 5. With extract_waypoints parameter
 
 ```bash
 python -m app --extract_waypoints True input
 ```
 
-### 4. With elevation parameter
+### 6. With elevation parameter
 
 ```bash
 python -m app --elevation True input

{config_cli_gui-0.1.0 → config_cli_gui-0.1.2}/docs/usage/config.md

@@ -37,3 +37,11 @@ The parameters in the cli category can be accessed via the command line interfac
 | auto_scroll_log   | bool | Automatically scroll to newest log entries | True    | [True, False]             |
 | max_log_lines     | int  | Maximum number of log lines to keep in GUI | 1000    | -                         |
 
+## Category "misc"
+
+| Name       | Type        | Description                       | Default                                            | Choices |
+|------------|-------------|-----------------------------------|----------------------------------------------------|---------|
+| some_file  | WindowsPath | Path to the file to use           | WindowsPath('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, 6, 23, 18, 58, 52, 946103) | -       |
+

{config_cli_gui-0.1.0 → config_cli_gui-0.1.2}/src/config_cli_gui/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)

{config_cli_gui-0.1.0 → config_cli_gui-0.1.2}/src/config_cli_gui/cli_generator.py

@@ -46,6 +46,8 @@ class CliGenerator:
 
         # Generate arguments from CLI config parameters
         for param in cli_params:
+            param_type = type(param.default)
+
             if param.required and param.cli_arg is None:
                 # Positional argument
                 parser.add_argument(param.name, help=param.help)
@@ -57,17 +59,17 @@ class CliGenerator:
                 }
 
                 # Handle different parameter types
-                if param.choices and param.type_ != bool:
+                if param.choices and param_type != bool:
                     kwargs["choices"] = param.choices
 
-                if param.type_ == int:
+                if param_type == int:
                     kwargs["type"] = int
-                elif param.type_ == float:
+                elif param_type == float:
                     kwargs["type"] = float
-                elif param.type_ == bool:
+                elif param_type == bool:
                     kwargs["action"] = "store_true" if not param.default else "store_false"
                     kwargs["help"] = f"{param.help} (default: {param.default})"
-                elif param.type_ == str:
+                elif param_type == str:
                     kwargs["type"] = str
 
                 parser.add_argument(param.cli_arg, **kwargs)

config_cli_gui-0.1.2/src/config_cli_gui/config_framework.py

@@ -0,0 +1,281 @@
+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]) -> "Color":
+        if len(rgb_list) >= 3:
+            return cls(rgb_list[0], rgb_list[1], 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 all its metadata."""
+
+    name: str
+    default: Any
+    choices: list | tuple | None = None
+    help: str = ""
+    cli_arg: str = 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.default, bool) and self.choices is None:
+            self.choices = [True, False]
+
+    @property
+    def type_(self) -> type:
+        """Get the type from the default value."""
+        return type(self.default)
+
+
+class BaseConfigCategory(BaseModel, ABC):
+    """Base class for configuration categories."""
+
+    @abstractmethod
+    def get_category_name(self) -> str:
+        """Return the category name for this configuration group."""
+        pass
+
+    def get_parameters(self) -> list[ConfigParameter]:
+        """Get all ConfigParameter objects from this category."""
+        parameters = []
+        for field_name in self.__class__.model_fields:
+            param = getattr(self, field_name)
+            if isinstance(param, ConfigParameter):
+                param.category = self.get_category_name()
+                parameters.append(param)
+        return parameters
+
+
+class ConfigManager:
+    """Generic configuration manager that can handle multiple configuration categories."""
+
+    def __init__(
+        self, categories: tuple[BaseConfigCategory, ...], config_file: str = None, **kwargs
+    ):
+        """Initialize configuration manager.
+
+        Args:
+            config_file: Path to configuration file (JSON or YAML)
+            **kwargs: Override parameters in format category__parameter
+        """
+        self._categories: dict[str, BaseConfigCategory] = {}
+
+        for category in categories:
+            if isinstance(category, BaseConfigCategory):
+                self.add_category(category.get_category_name(), category)
+            else:
+                raise TypeError(
+                    f"Category must be an instance of BaseConfigCategory, got {type(category)}"
+                )
+
+        # Load from file if provided
+        if config_file:
+            self.load_from_file(config_file)
+
+        # Override with provided kwargs
+        self._apply_kwargs(kwargs)
+
+    def add_category(self, name: str, category: BaseConfigCategory):
+        """Add a configuration category.
+
+        Args:
+            name: Name of the category (e.g., 'app', 'database', 'gui')
+            category: Configuration category instance
+        """
+        self._categories[name] = category
+
+    def get_category(self, name: str) -> BaseConfigCategory:
+        """Get a configuration category by name."""
+        return self._categories.get(name)
+
+    def _apply_kwargs(self, kwargs: dict[str, Any]):
+        """Apply keyword arguments to override configuration values."""
+        for key, value in kwargs.items():
+            if "__" in key:
+                category_name, param_name = key.split("__", 1)
+                if category_name in self._categories:
+                    category = self._categories[category_name]
+                    if hasattr(category, param_name):
+                        param = getattr(category, param_name)
+                        if isinstance(param, ConfigParameter):
+                            param.default = value
+
+    def load_from_file(self, config_file: str):
+        """Load configuration from JSON or YAML file."""
+        config_path = Path(config_file)
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_file}")
+
+        with open(config_path, "r", encoding="utf-8") as f:
+            if config_path.suffix.lower() in [".yml", ".yaml"]:
+                config_data = yaml.safe_load(f)
+            else:
+                config_data = json.load(f)
+
+        # Store loaded data for later application
+        self._apply_config_data(config_data)
+
+    def _apply_config_data(self, _loaded_config_data):
+        """Apply configuration data to categories."""
+
+        # Apply loaded configuration
+        for category_name, category_data in _loaded_config_data.items():
+            if category_name in self._categories:
+                category = self._categories[category_name]
+                for param_name, param_value in category_data.items():
+                    if hasattr(category, param_name):
+                        param = getattr(category, param_name)
+                        if isinstance(param, ConfigParameter):
+                            # Handle special types
+                            if isinstance(param.default, Color) and isinstance(param_value, list):
+                                param.default = Color.from_list(param_value)
+                            elif isinstance(param.default, Path):
+                                param.default = Path(param_value)
+                            elif isinstance(param.default, datetime):
+                                param.default = datetime.fromisoformat(param_value)
+                            else:
+                                param.default = param_value
+
+    def save_to_file(self, config_file: str, format_: str = "auto"):
+        """Save current configuration to file with enhanced YAML formatting and comments.
+
+        Args:
+            config_file (str): The path to the configuration file.
+            format_ (str): The format to save the file in ('auto', 'json', 'yaml').
+        """
+        config_path = Path(config_file)
+        config_data = self.to_dict()
+
+        # Determine format
+        if format_ == "auto":
+            format_ = "yaml" if config_path.suffix.lower() in [".yml", ".yaml"] else "json"
+
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(config_path, "w", encoding="utf-8") as f:
+            if format_ == "yaml":
+                yaml.dump(config_data, f, default_flow_style=False, indent=2)
+            else:
+                json.dump(config_data, f, indent=2)
+
+        # Append comments for YAML files
+        if format_ == "yaml":
+            self._append_comments_to_yaml(config_path)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert configuration to dictionary."""
+        result = {}
+        for category_name, category in self._categories.items():
+            category_dict = {}
+            for param in category.get_parameters():
+                value = param.default
+                # Handle special types for serialization
+                if isinstance(value, Color):
+                    value = value.to_list()
+                elif isinstance(value, Path):
+                    value = str(value)
+                elif isinstance(value, datetime):
+                    value = value.isoformat()
+                category_dict[param.name] = value
+            result[category_name] = category_dict
+        return result
+
+    def get_all_parameters(self) -> list[ConfigParameter]:
+        """Get all parameters from all categories."""
+        parameters = []
+        for category in self._categories.values():
+            parameters.extend(category.get_parameters())
+        return parameters
+
+    def get_cli_parameters(self) -> list[ConfigParameter]:
+        """Get parameters that are CLI-enabled."""
+        cli_parameters = []
+        for category in self._categories.values():
+            for param in category.get_parameters():
+                if param.is_cli:
+                    cli_parameters.append(param)
+        return cli_parameters
+
+    def _append_comments_to_yaml(self, config_path: Path):
+        """Appends comments to a YAML file based on ConfigParameter metadata.
+
+        Args:
+            config_path (Path): The path to the YAML configuration file.
+        """
+        lines = config_path.read_text(encoding="utf-8").splitlines()
+        new_lines = []
+        all_parameters = {param.name: param for param in self.get_all_parameters()}
+        current_category = None
+
+        for line in lines:
+            stripped_line = line.strip()
+            # Check for category (e.g., 'app:')
+            # A category should end with ':', not start with '#', and not be indented.
+            if (
+                stripped_line.endswith(":")
+                and not stripped_line.startswith("#")
+                and line.startswith(stripped_line)
+            ):
+                current_category = stripped_line[:-1]
+                new_lines.append(line)
+            else:
+                # Check for parameter (e.g., '  date_format: '%Y-%m-%d'')
+                # This needs to handle cases where the value spans multiple lines
+                parts = stripped_line.split(":", 1)
+                if len(parts) > 1:  # This line might be a parameter definition
+                    param_name = parts[0].strip()
+                    if param_name in all_parameters:
+                        param = all_parameters[param_name]
+                        # Ensure the parameter belongs to the current category
+                        # and is not a sub-item of a multi-line value
+                        if current_category and param.category == current_category:
+                            comment_indent = " " * (len(line) - len(stripped_line))
+                            comment = (
+                                f"{comment_indent}# {param.help} | "
+                                f"type={type(param).__name__}, default={param.default}"
+                            )
+                            new_lines.append(comment)
+                new_lines.append(line)
+        config_path.write_text("\n".join(new_lines), encoding="utf-8")