config-cli-gui 0.0.2__py3-none-any.whl

example_project/cli/cli.py

@@ -0,0 +1,132 @@
+"""CLI interface for config-cli-gui using the generic config framework.
+
+This file uses the CliGenerator from the generic config framework.
+"""
+
+from pathlib import Path
+
+from config_cli_gui.cli_generator import CliGenerator
+from config_cli_gui.config.config import ConfigParameterManager
+from config_cli_gui.core.base import BaseGPXProcessor
+from config_cli_gui.core.logging import initialize_logging
+
+
+def validate_config(config: ConfigParameterManager, logger) -> bool:
+    """Validate the configuration parameters.
+
+    Args:
+        config: Configuration manager instance
+        logger: Logger instance for error reporting
+
+    Returns:
+        True if configuration is valid, False otherwise
+    """
+    # Get CLI category and check required parameters
+    cli_category = config.get_cli_category()
+    if not cli_category:
+        logger.error("No CLI configuration found")
+        return False
+
+    # Check if input parameter exists and has a value
+    input_param = getattr(cli_category, "input", None)
+    if not input_param or not input_param.default:
+        logger.error("Input is required")
+        return False
+
+    # Check if input file exists
+    input_path = Path(input_param.default)
+    if not input_path.exists():
+        logger.error(f"File not found: {input_path}")
+        return False
+
+    logger.debug(f"Input file validation passed: {input_path}")
+    return True
+
+
+def run_main_processing(config: ConfigParameterManager) -> int:
+    """Main processing function that gets called by the CLI generator.
+
+    Args:
+        config: Configuration manager with all settings
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    # Initialize logging system
+    logger_manager = initialize_logging(config)
+    logger = logger_manager.get_logger("config_cli_gui.cli")
+
+    try:
+        # Log startup information
+        logger.info("Starting config_cli_gui CLI")
+        logger_manager.log_config_summary()
+
+        # Validate configuration
+        if not validate_config(config, logger):
+            logger.error("Configuration validation failed")
+            return 1
+
+        # Get CLI parameters
+        cli_category = config.get_cli_category()
+        input_file = cli_category.input.default
+        output_file = cli_category.output.default
+        min_dist = cli_category.min_dist.default
+        extract_waypoints = cli_category.extract_waypoints.default
+
+        # Get app parameters
+        app_category = config.get_category("app")
+        date_format = app_category.date_format.default if app_category else "%Y-%m-%d"
+
+        logger.info(f"Processing input: {input_file}")
+
+        # Create and run BaseGPXProcessor
+        processor = BaseGPXProcessor(
+            input_=input_file,
+            output=output_file,
+            min_dist=min_dist,
+            date_format=date_format,
+            elevation=extract_waypoints,
+            logger=logger,
+        )
+
+        logger.info("Starting conversion process")
+
+        # Run the processing (adjust method name based on your actual implementation)
+        result_files = processor.compress_files()
+
+        logger.info(f"Successfully processed: {input_file}")
+        if output_file:
+            logger.info(f"Output written to: {output_file}")
+        if result_files:
+            logger.info(f"Generated files: {', '.join(result_files)}")
+
+        logger.info("CLI processing completed successfully")
+        return 0
+
+    except Exception as e:
+        logger.error(f"Processing failed: {e}")
+        logger.debug("Full traceback:", exc_info=True)
+        return 1
+
+
+def main():
+    """Main entry point for the CLI application."""
+    # Create the base configuration manager
+    config_manager = ConfigParameterManager()
+
+    # Create CLI generator
+    cli_generator = CliGenerator(config_manager=config_manager, app_name="config_cli_gui")
+
+    # Run the CLI with our main processing function
+    return cli_generator.run_cli(
+        main_function=run_main_processing,
+        description="Process GPX files with various operations like compression, "
+        "merging, and POI extraction",
+        validator=validate_config,
+    )
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

example_project/config/config.py

@@ -0,0 +1,209 @@
+"""Central configuration management for config-cli-gui project.
+
+This module provides a single source of truth for all configuration parameters
+organized in categories (CLI, App, GUI). It can generate config files, CLI modules,
+and documentation from the parameter definitions.
+"""
+
+from config_cli_gui.config_framework import (
+    BaseConfigCategory,
+    CliConfigCategory,
+    ConfigManager,
+    ConfigParameter,
+    DocumentationGenerator,
+)
+
+
+class CliConfig(CliConfigCategory):
+    """CLI-specific configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "cli"
+
+    # Positional argument
+    input: ConfigParameter = ConfigParameter(
+        name="input",
+        default="",
+        type_=str,
+        help="Path to input (file or folder)",
+        required=True,
+        cli_arg=None,  # Positional argument
+    )
+
+    # Optional CLI arguments
+    output: ConfigParameter = ConfigParameter(
+        name="output",
+        default="",
+        type_=str,
+        help="Path to output destination",
+    )
+
+    min_dist: ConfigParameter = ConfigParameter(
+        name="min_dist",
+        default=20,
+        type_=int,
+        help="Maximum distance between two waypoints",
+    )
+
+    extract_waypoints: ConfigParameter = ConfigParameter(
+        name="extract_waypoints",
+        default=True,
+        type_=bool,
+        help="Extract starting points of each track as waypoint",
+    )
+
+    elevation: ConfigParameter = ConfigParameter(
+        name="elevation",
+        default=True,
+        type_=bool,
+        help="Include elevation data in waypoints",
+    )
+
+
+class AppConfig(BaseConfigCategory):
+    """Application-specific configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "app"
+
+    date_format: ConfigParameter = ConfigParameter(
+        name="date_format",
+        default="%Y-%m-%d",
+        type_=str,
+        help="Date format to use",
+    )
+
+    log_level: ConfigParameter = ConfigParameter(
+        name="log_level",
+        default="INFO",
+        type_=str,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Logging level for the application",
+    )
+
+    log_file_max_size: ConfigParameter = ConfigParameter(
+        name="log_file_max_size",
+        default=10,
+        type_=int,
+        help="Maximum log file size in MB before rotation",
+    )
+
+    log_backup_count: ConfigParameter = ConfigParameter(
+        name="log_backup_count",
+        default=5,
+        type_=int,
+        help="Number of backup log files to keep",
+    )
+
+    log_format: ConfigParameter = ConfigParameter(
+        name="log_format",
+        default="detailed",
+        type_=str,
+        choices=["simple", "detailed", "json"],
+        help="Log message format style",
+    )
+
+    max_workers: ConfigParameter = ConfigParameter(
+        name="max_workers",
+        default=4,
+        type_=int,
+        help="Maximum number of worker threads",
+    )
+
+    enable_file_logging: ConfigParameter = ConfigParameter(
+        name="enable_file_logging",
+        default=True,
+        type_=bool,
+        help="Enable logging to file",
+    )
+
+    enable_console_logging: ConfigParameter = ConfigParameter(
+        name="enable_console_logging",
+        default=True,
+        type_=bool,
+        help="Enable logging to console",
+    )
+
+
+class GuiConfig(BaseConfigCategory):
+    """GUI-specific configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "gui"
+
+    theme: ConfigParameter = ConfigParameter(
+        name="theme",
+        default="light",
+        type_=str,
+        choices=["light", "dark", "auto"],
+        help="GUI theme setting",
+    )
+
+    window_width: ConfigParameter = ConfigParameter(
+        name="window_width",
+        default=800,
+        type_=int,
+        help="Default window width",
+    )
+
+    window_height: ConfigParameter = ConfigParameter(
+        name="window_height",
+        default=600,
+        type_=int,
+        help="Default window height",
+    )
+
+    log_window_height: ConfigParameter = ConfigParameter(
+        name="log_window_height",
+        default=200,
+        type_=int,
+        help="Height of the log window in pixels",
+    )
+
+    auto_scroll_log: ConfigParameter = ConfigParameter(
+        name="auto_scroll_log",
+        default=True,
+        type_=bool,
+        help="Automatically scroll to newest log entries",
+    )
+
+    max_log_lines: ConfigParameter = ConfigParameter(
+        name="max_log_lines",
+        default=1000,
+        type_=int,
+        help="Maximum number of log lines to keep in GUI",
+    )
+
+
+class ConfigParameterManager(ConfigManager):  # Inherit from ConfigManager
+    """Main configuration manager that handles all parameter categories."""
+
+    def __init__(self, config_file: str | None = None, **kwargs):
+        # Erst den Parent initialisieren
+        super().__init__(config_file, **kwargs)
+
+        # Dann die Kategorien hinzufügen
+        self.add_category("cli", CliConfig())
+        self.add_category("app", AppConfig())
+        self.add_category("gui", GuiConfig())
+
+
+def main():
+    """Main function to generate config file and documentation."""
+    default_config: str = "../../config.yaml"
+    default_cli_doc: str = "../../docs/usage/cli.md"
+    default_config_doc: str = "../../docs/usage/config.md"
+    config_manager = ConfigParameterManager()
+    docGen = DocumentationGenerator(config_manager)
+    docGen.generate_default_config_file(output_file=default_config)
+    print(f"Generated: {default_config}")
+
+    docGen.generate_config_markdown_doc(output_file=default_config_doc)
+    print(f"Generated: {default_config_doc}")
+
+    docGen.generate_cli_markdown_doc(output_file=default_cli_doc)
+    print(f"Generated: {default_cli_doc}")
+
+
+if __name__ == "__main__":
+    main()