config-cli-gui 0.0.2__tar.gz → 0.1.1__tar.gz

{config_cli_gui-0.0.2 → config_cli_gui-0.1.1}/.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.1/HISTORY.md

@@ -0,0 +1,16 @@
+Changelog
+=========
+
+
+(unreleased)
+------------
+- 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.0.2/src/config_cli_gui.egg-info → config_cli_gui-0.1.1}/PKG-INFO

@@ -1,17 +1,13 @@
 Metadata-Version: 2.4
 Name: config-cli-gui
-Version: 0.0.2
+Version: 0.1.1
 Summary: Feature-rich Python project template for config-cli-gui.
 Author: pamagister
 Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastkml>=1.1.0
-Requires-Dist: gpxpy>=1.6.2
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: shapely>=2.1.1
-Requires-Dist: srtm-py>=0.3.7
 Provides-Extra: dev
 Requires-Dist: pytest>=8.4.0; extra == "dev"
 Requires-Dist: pytest-mock>=3.14.1; extra == "dev"
@@ -31,7 +27,9 @@ Requires-Dist: mkdocs-awesome-nav>=2.6.1; extra == "docs"
 Requires-Dist: pygments>=2.19.1; extra == "docs"
 Dynamic: license-file
 
-# config-cli-gui: Unified Configuration and Interface Management
+# Welcome to config-cli-gui
+
+**Unified Configuration and Interface Management**
 
 Provides a generic configuration framework that automatically generates both command-line interfaces and GUI settings dialogs from configuration parameters. 
 
@@ -57,7 +55,7 @@ You can install `config-cli-gui` using pip:
 
 ```bash
 pip install config-cli-gui
-````
+```
 
 ---
 

{config_cli_gui-0.0.2 → config_cli_gui-0.1.1}/README.md

@@ -1,6 +1,8 @@
 <!-- This README.md is auto-generated from docs/index.md -->
 
-# config-cli-gui: Unified Configuration and Interface Management
+# Welcome to config-cli-gui
+
+**Unified Configuration and Interface Management**
 
 Provides a generic configuration framework that automatically generates both command-line interfaces and GUI settings dialogs from configuration parameters. 
 
@@ -26,7 +28,7 @@ You can install `config-cli-gui` using pip:
 
 ```bash
 pip install config-cli-gui
-````
+```
 
 ---
 

{config_cli_gui-0.0.2 → config_cli_gui-0.1.1}/docs/index.md

@@ -1,4 +1,6 @@
-# config-cli-gui: Unified Configuration and Interface Management
+# Welcome to config-cli-gui
+
+**Unified Configuration and Interface Management**
 
 Provides a generic configuration framework that automatically generates both command-line interfaces and GUI settings dialogs from configuration parameters. 
 
@@ -24,7 +26,7 @@ You can install `config-cli-gui` using pip:
 
 ```bash
 pip install config-cli-gui
-````
+```
 
 ---
 

{config_cli_gui-0.0.2 → config_cli_gui-0.1.1}/pyproject.toml

@@ -8,12 +8,8 @@ authors = [
 readme = "docs/index.md"
 requires-python = ">=3.10,<3.12"
 dependencies = [
-    "fastkml>=1.1.0",
-    "gpxpy>=1.6.2",
     "pydantic>=2.11.7",
     "pyyaml>=6.0.2",
-    "shapely>=2.1.1",
-    "srtm-py>=0.3.7",
 ]
 
 # Dev dependencies as optional dependencies

{config_cli_gui-0.0.2 → config_cli_gui-0.1.1}/src/config_cli_gui/_version.py

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

{config_cli_gui-0.0.2 → config_cli_gui-0.1.1}/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.1/src/config_cli_gui/config_framework.py

@@ -0,0 +1,217 @@
+# config_framework/core.py
+"""Generic configuration framework for Python applications."""
+
+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, 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] = {}
+
+        # 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)
+
+        # Apply loaded configuration
+        for category_name, category_data in 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."""
+        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)
+
+    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

config_cli_gui-0.1.1/src/config_cli_gui/docs_generator.py

@@ -0,0 +1,190 @@
+from pathlib import Path
+from textwrap import dedent
+
+from config_cli_gui.config_framework import ConfigManager
+
+
+class DocumentationGenerator:
+    """Generates documentation and configuration files from ConfigManager."""
+
+    def __init__(self, config_manager: ConfigManager):
+        self.config_manager = config_manager
+
+    def generate_config_markdown_doc(self, output_file: str):
+        """Generate Markdown documentation for all configuration parameters."""
+
+        def pad(s, width):
+            return s + " " * (width - len(s))
+
+        markdown_content = dedent("""
+            # Configuration Parameters
+
+            These parameters are available to configure the behavior of your application.
+            The parameters in the cli category can be accessed via the command line interface.
+
+            """).lstrip()
+
+        for category_name, category in self.config_manager._categories.items():
+            markdown_content += f'## Category "{category_name}"\n\n'
+
+            # Collect all parameters for this category
+            rows = []
+            header = ["Name", "Type", "Description", "Default", "Choices"]
+
+            for param in category.get_parameters():
+                name = param.name
+                typ = type(param.default).__name__
+                desc = param.help
+                default = repr(param.default)
+                choices = str(param.choices) if param.choices else "-"
+
+                rows.append((name, typ, desc, default, choices))
+
+            if not rows:
+                continue
+
+            # Calculate column widths
+            all_rows = [header] + rows
+            widths = [max(len(str(col)) for col in column) for column in zip(*all_rows)]
+
+            # Create Markdown table
+            table = (
+                "| "
+                + " | ".join(pad(h, w) for h, w in zip(header, widths))
+                + " |\n"
+                + "|-"
+                + "-|-".join("-" * w for w in widths)
+                + "-|\n"
+            )
+            for row in rows:
+                table += "| " + " | ".join(pad(str(col), w) for col, w in zip(row, widths)) + " |\n"
+
+            markdown_content += table + "\n"
+
+        # Write to file
+        Path(output_file).parent.mkdir(parents=True, exist_ok=True)
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(markdown_content)
+
+    def generate_default_config_file(self, output_file: str):
+        """Generate a default configuration file with all parameters and descriptions."""
+        output_path = Path(output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write("# Configuration File\n")
+            f.write("# This file was auto-generated. Modify as needed.\n\n")
+
+            for category_name, category in self.config_manager._categories.items():
+                f.write(f"# {category_name.upper()} Configuration\n")
+                f.write(f"{category_name}:\n")
+
+                for param in category.get_parameters():
+                    f.write(f"  # {param.help}\n")
+                    if param.choices:
+                        f.write(f"  # Choices: {param.choices}\n")
+                    f.write(f"  # Type: {type(param.default).__name__}\n")
+                    f.write(f"  {param.name}: {repr(param.default)}\n\n")
+
+                f.write("\n")
+
+    def generate_cli_markdown_doc(self, output_file: str, app_name: str = "app"):
+        """Generate Markdown CLI documentation."""
+        cli_params = self.config_manager.get_cli_parameters()
+
+        if not cli_params:
+            return
+
+        rows = []
+        required_params = []
+        optional_params = []
+
+        for param in cli_params:
+            cli_arg = f"`--{param.name}`" if not param.required else f"`{param.name}`"
+            typ = type(param.default).__name__
+            desc = param.help
+            default = (
+                "*required*"
+                if param.required or param.default in (None, "")
+                else repr(param.default)
+            )
+            choices = str(param.choices) if param.choices else "-"
+
+            rows.append((cli_arg, typ, desc, default, choices))
+            if default == "*required*":
+                required_params.append(param)
+            else:
+                optional_params.append(param)
+
+        # Generate table
+        def pad(s, width):
+            return s + " " * (width - len(s))
+
+        widths = [max(len(str(col)) for col in column) for column in zip(*rows)]
+        header = ["Option", "Type", "Description", "Default", "Choices"]
+
+        table = (
+            "| "
+            + " | ".join(pad(h, w) for h, w in zip(header, widths))
+            + " |\n"
+            + "|-"
+            + "-|-".join("-" * w for w in widths)
+            + "-|\n"
+        )
+        for row in rows:
+            table += "| " + " | ".join(pad(str(col), w) for col, w in zip(row, widths)) + " |\n"
+
+        # Generate examples
+        examples = []
+        required_arg = required_params[0].name if required_params else "example.input"
+
+        examples.append(
+            dedent(
+                f"""
+            ### 1. Basic usage
+
+            ```bash
+            python -m {app_name} {required_arg}
+            ```
+            """
+            )
+        )
+
+        # Add more examples with optional parameters
+        for i, param in enumerate(optional_params[:3], 2):
+            if param.name in ["verbose", "quiet"]:
+                continue
+            example_value = param.choices[0] if param.choices else param.default
+            examples.append(
+                dedent(f"""
+                ### {i}. With {param.name} parameter
+
+                ```bash
+                python -m {app_name} --{param.name} {example_value} {required_arg}
+                ```
+                """)
+            )
+
+        markdown = dedent(
+            f"""
+            # Command Line Interface
+
+Command line options for {app_name}
+
+```bash
+python -m {app_name} [OPTIONS] {required_arg if required_params else ""}
+```
+
+## Options
+
+{table}
+
+## Examples
+
+            {"".join(examples)}
+            """
+        ).strip()
+
+        Path(output_file).parent.mkdir(parents=True, exist_ok=True)
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(markdown)