python-template-project 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

python_template_project/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
+
+__commit_id__ = commit_id = None

python_template_project/cli/cli.py

@@ -5,7 +5,8 @@ This file uses the CliGenerator from the generic config framework.
 
 from pathlib import Path
 
-from generic_config_cli_gui.cli_generator import CliGenerator
+from config_cli_gui.cli import CliGenerator
+
 from python_template_project.config.config import ConfigParameterManager
 from python_template_project.core.base import BaseGPXProcessor
 from python_template_project.core.logging import initialize_logging
@@ -22,19 +23,19 @@ def validate_config(config: ConfigParameterManager, logger) -> bool:
         True if configuration is valid, False otherwise
     """
     # Get CLI category and check required parameters
-    cli_category = config.get_cli_category()
+    cli_category = config.cli
     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:
+    input_param = getattr(cli_category, "input")
+    if not input_param or not input_param.value:
         logger.error("Input is required")
         return False
 
     # Check if input file exists
-    input_path = Path(input_param.default)
+    input_path = Path(input_param.value)
     if not input_path.exists():
         logger.error(f"File not found: {input_path}")
         return False
@@ -67,15 +68,15 @@ def run_main_processing(config: ConfigParameterManager) -> int:
             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
+        cli_category = config.cli
+        input_file = cli_category.input.value
+        output_file = cli_category.output.value
+        min_dist = cli_category.min_dist.value
+        extract_waypoints = cli_category.extract_waypoints.value
 
         # Get app parameters
-        app_category = config.get_category("app")
-        date_format = app_category.date_format.default if app_category else "%Y-%m-%d"
+        app_category = config.app
+        date_format = app_category.date_format.value if app_category else "%Y-%m-%d"
 
         logger.info(f"Processing input: {input_file}")
 

python_template_project/config/config.py

@@ -1,20 +1,15 @@
-"""Central configuration management for python-template-project project.
+"""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 generic_config_cli_gui.config_framework import (
-    BaseConfigCategory,
-    CliConfigCategory,
-    ConfigManager,
-    ConfigParameter,
-    DocumentationGenerator,
-)
+from config_cli_gui.config import ConfigCategory, ConfigManager, ConfigParameter
+from config_cli_gui.docs import DocumentationGenerator
 
 
-class CliConfig(CliConfigCategory):
+class CliConfig(ConfigCategory):
     """CLI-specific configuration parameters."""
 
     def get_category_name(self) -> str:
@@ -23,44 +18,43 @@ class CliConfig(CliConfigCategory):
     # Positional argument
     input: ConfigParameter = ConfigParameter(
         name="input",
-        default="",
-        type_=str,
+        value="",
         help="Path to input (file or folder)",
         required=True,
-        cli_arg=None,  # Positional argument
+        is_cli=True,
     )
 
     # Optional CLI arguments
     output: ConfigParameter = ConfigParameter(
         name="output",
-        default="",
-        type_=str,
+        value="",
         help="Path to output destination",
+        is_cli=True,
     )
 
     min_dist: ConfigParameter = ConfigParameter(
         name="min_dist",
-        default=20,
-        type_=int,
+        value=20,
         help="Maximum distance between two waypoints",
+        is_cli=True,
     )
 
     extract_waypoints: ConfigParameter = ConfigParameter(
         name="extract_waypoints",
-        default=True,
-        type_=bool,
+        value=True,
         help="Extract starting points of each track as waypoint",
+        is_cli=True,
     )
 
     elevation: ConfigParameter = ConfigParameter(
         name="elevation",
-        default=True,
-        type_=bool,
+        value=True,
         help="Include elevation data in waypoints",
+        is_cli=True,
     )
 
 
-class AppConfig(BaseConfigCategory):
+class AppConfig(ConfigCategory):
     """Application-specific configuration parameters."""
 
     def get_category_name(self) -> str:
@@ -68,64 +62,56 @@ class AppConfig(BaseConfigCategory):
 
     date_format: ConfigParameter = ConfigParameter(
         name="date_format",
-        default="%Y-%m-%d",
-        type_=str,
+        value="%Y-%m-%d",
         help="Date format to use",
     )
 
     log_level: ConfigParameter = ConfigParameter(
         name="log_level",
-        default="INFO",
-        type_=str,
+        value="INFO",
         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,
+        value=10,
         help="Maximum log file size in MB before rotation",
     )
 
     log_backup_count: ConfigParameter = ConfigParameter(
         name="log_backup_count",
-        default=5,
-        type_=int,
+        value=5,
         help="Number of backup log files to keep",
     )
 
     log_format: ConfigParameter = ConfigParameter(
         name="log_format",
-        default="detailed",
-        type_=str,
+        value="detailed",
         choices=["simple", "detailed", "json"],
         help="Log message format style",
     )
 
     max_workers: ConfigParameter = ConfigParameter(
         name="max_workers",
-        default=4,
-        type_=int,
+        value=4,
         help="Maximum number of worker threads",
     )
 
     enable_file_logging: ConfigParameter = ConfigParameter(
         name="enable_file_logging",
-        default=True,
-        type_=bool,
+        value=True,
         help="Enable logging to file",
     )
 
     enable_console_logging: ConfigParameter = ConfigParameter(
         name="enable_console_logging",
-        default=True,
-        type_=bool,
+        value=True,
         help="Enable logging to console",
     )
 
 
-class GuiConfig(BaseConfigCategory):
+class GuiConfig(ConfigCategory):
     """GUI-specific configuration parameters."""
 
     def get_category_name(self) -> str:
@@ -133,44 +119,38 @@ class GuiConfig(BaseConfigCategory):
 
     theme: ConfigParameter = ConfigParameter(
         name="theme",
-        default="light",
-        type_=str,
+        value="light",
         choices=["light", "dark", "auto"],
         help="GUI theme setting",
     )
 
     window_width: ConfigParameter = ConfigParameter(
         name="window_width",
-        default=800,
-        type_=int,
+        value=800,
         help="Default window width",
     )
 
     window_height: ConfigParameter = ConfigParameter(
         name="window_height",
-        default=600,
-        type_=int,
+        value=600,
         help="Default window height",
     )
 
     log_window_height: ConfigParameter = ConfigParameter(
         name="log_window_height",
-        default=200,
-        type_=int,
+        value=200,
         help="Height of the log window in pixels",
     )
 
     auto_scroll_log: ConfigParameter = ConfigParameter(
         name="auto_scroll_log",
-        default=True,
-        type_=bool,
+        value=True,
         help="Automatically scroll to newest log entries",
     )
 
     max_log_lines: ConfigParameter = ConfigParameter(
         name="max_log_lines",
-        default=1000,
-        type_=int,
+        value=1000,
         help="Maximum number of log lines to keep in GUI",
     )
 
@@ -178,14 +158,14 @@ class GuiConfig(BaseConfigCategory):
 class ConfigParameterManager(ConfigManager):  # Inherit from ConfigManager
     """Main configuration manager that handles all parameter categories."""
 
+    cli: CliConfig
+    app: AppConfig
+    gui: GuiConfig
+
     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())
+        categories = (CliConfig(), AppConfig(), GuiConfig())
+        super().__init__(categories, config_file, **kwargs)
 
 
 def main():
@@ -194,14 +174,14 @@ def main():
     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)
+    doc_gen = DocumentationGenerator(config_manager)
+    doc_gen.generate_default_config_file(output_file=default_config)
     print(f"Generated: {default_config}")
 
-    docGen.generate_config_markdown_doc(output_file=default_config_doc)
+    doc_gen.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)
+    doc_gen.generate_cli_markdown_doc(output_file=default_cli_doc)
     print(f"Generated: {default_cli_doc}")
 
 

python_template_project/core/logging.py

@@ -12,7 +12,7 @@ import logging.handlers
 import sys
 from pathlib import Path
 
-from generic_config_cli_gui.config_framework import ConfigManager
+from python_template_project.config.config import ConfigParameterManager
 
 
 class GuiLogHandler(logging.Handler):
@@ -39,7 +39,7 @@ class GuiLogHandler(logging.Handler):
 class LoggerManager:
     """Manages all logging configuration and handlers."""
 
-    def __init__(self, config: ConfigManager):
+    def __init__(self, config: ConfigParameterManager):
         self.config = config
         self.logger = logging.getLogger("python_template_project")
         self.gui_handler = None
@@ -53,7 +53,7 @@ class LoggerManager:
         self.logger.handlers.clear()
 
         # Set log level from config
-        log_level = getattr(logging, self.config.get_category("app").log_level.default.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.default = 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.get_category('app').log_level.default}")
-        self.logger.info(f"Input: {self.config.get_category('cli').input.default}")
-        self.logger.info(f"Output: {self.config.get_category('cli').output.default}")
-        self.logger.info(f"Max workers: {self.config.get_category('app').max_workers.default}")
+        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("==============================")
 
 
@@ -158,7 +158,7 @@ class LoggerManager:
 _logger_manager = None
 
 
-def initialize_logging(config: ConfigManager) -> LoggerManager:
+def initialize_logging(config: ConfigParameterManager) -> LoggerManager:
     """Initialize the global logging system.
 
     Args:

python_template_project/gui/gui.py

@@ -17,7 +17,8 @@ from functools import partial
 from pathlib import Path
 from tkinter import filedialog, messagebox, ttk
 
-from generic_config_cli_gui.gui_generator import SettingsDialogGenerator
+from config_cli_gui.gui import SettingsDialogGenerator
+
 from python_template_project.config.config import ConfigParameterManager
 from python_template_project.core.base import BaseGPXProcessor
 from python_template_project.core.logging import (
@@ -241,9 +242,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_manager.get_category("app").log_level.default
-        )
+        self.log_level_var = tk.StringVar(value=self.config_manager.app.log_level.value)
         log_level_combo = ttk.Combobox(
             log_controls,
             textvariable=self.log_level_var,
@@ -456,10 +455,10 @@ class MainGui:
             # Create and run project
             project = BaseGPXProcessor(
                 files_to_process,  # Pass selected files
-                self.config_manager.get_category("cli").output.default,
-                self.config_manager.get_category("cli").min_dist.default,
-                self.config_manager.get_category("app").date_format.default,
-                self.config_manager.get_category("cli").elevation.default,
+                self.config_manager.cli.output.value,
+                self.config_manager.cli.min_dist.value,
+                self.config_manager.app.date_format.value,
+                self.config_manager.cli.elevation.value,
                 self.logger,
             )
             # implement switch case for different processing modes
@@ -506,7 +505,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_manager.get_category("app").log_level.default)
+            self.log_level_var.set(self.config_manager.app.log_level.value)
 
     def _open_help(self):
         """Open help documentation in browser."""

{python_template_project-0.2.0.dist-info → python_template_project-0.2.1.dist-info}/METADATA

@@ -1,15 +1,14 @@
 Metadata-Version: 2.4
 Name: python-template-project
-Version: 0.2.0
+Version: 0.2.1
 Summary: Feature-rich Python project template designed for robustness and ease of use.
 Author: pamagister
 Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: config-cli-gui>=0.2.0
 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
@@ -62,7 +61,7 @@ Getting started on developing your own project based on this template
 
 2. **Give a name to your project**  
    For example: `my-python-project`  
-   *(Hyphens may ne used as project name; they are converted during renaming internally to underscores for packages.)*
+   *(Hyphens may be used as project name; they are converted during renaming internally to underscores for packages.)*
 
 3. **Set write permissions**  
    Go to: `Repository -> Settings -> Actions -> General -> Workflow permissions`  

python_template_project-0.2.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+firewall_handler.py,sha256=qT0dInkeKHulpCQD2x3HH7_lMxz4lwdkIPxEvBSl3No,7336
+main.py,sha256=d6ZpnMxcPBf860gQmuYwPVJg1di6r2CR6gSvFLkAZkk,4448
+python_template_project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_template_project/__main__.py,sha256=JS28LiHoU9Xo4c_RvyLBTDKHqdZRRytJLj6qyrg26mQ,195
+python_template_project/_version.py,sha256=vYqoJTG51NOUmYyL0xt8asRK8vUT4lGAdal_EZ59mvw,704
+python_template_project/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_template_project/cli/__main__.py,sha256=qnGkoNNbhnvLTA24X8YTEDxRqDbNEAzgjp9Ki_JYIhs,184
+python_template_project/cli/cli.py,sha256=L5UiEeLzgYbbbKeWPKCVG7i509ou9mi6yNMc2K2UG_c,4201
+python_template_project/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_template_project/config/config.py,sha256=oTub_qmH4CbQQc7L354qJE5N3CRhajr0o8XULAUvzA8,5359
+python_template_project/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_template_project/core/base.py,sha256=3S_DSPgPom0wCS_tgdEaNpWub0r8GlytmjKtXlIypRA,28045
+python_template_project/core/logging.py,sha256=b5Z0g7XVj4fy7nYVfWMTSz8pV6tcXrNEJ6Y7pNJKfWA,6932
+python_template_project/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_template_project/gui/__main__.py,sha256=5AaiBxNCAKWcuSQFcQ_lsEQfEsXm6BA5-i5MScdf30c,184
+python_template_project/gui/gui.py,sha256=8jmwvrJlyez66cnkIoosq65KAx75WmAfwJUUiluh6TY,21647
+python_template_project-0.2.1.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+python_template_project-0.2.1.dist-info/METADATA,sha256=515IGLkUpYAHUiCaHrIsh_FXJd4H6RojXZmLQ8_RZos,7924
+python_template_project-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_template_project-0.2.1.dist-info/entry_points.txt,sha256=LmgMiqxIVRdD7gkktVBBR0CR4AhkugqlgifuglkPhtI,148
+python_template_project-0.2.1.dist-info/top_level.txt,sha256=O-Yg0tzEwgH58MhdcYWpJsgZSUPg6SBbOUwlmVHZo3A,55
+python_template_project-0.2.1.dist-info/RECORD,,

{python_template_project-0.2.0.dist-info → python_template_project-0.2.1.dist-info}/top_level.txt

@@ -1,5 +1,4 @@
 __init__
 firewall_handler
-generic_config_cli_gui
 main
 python_template_project

generic_config_cli_gui/cli_generator.py

@@ -1,177 +0,0 @@
-# generic_config_cli_gui/cli.py
-"""Generic CLI generator for configuration framework."""
-
-import argparse
-import traceback
-from collections.abc import Callable
-from typing import Any
-
-from generic_config_cli_gui.config_framework import ConfigManager
-
-
-class CliGenerator:
-    """Generates CLI interface from ConfigManager."""
-
-    def __init__(self, config_manager: ConfigManager, app_name: str = "app"):
-        self.config_manager = config_manager
-        self.app_name = app_name
-
-    def create_argument_parser(self, description: str = None) -> argparse.ArgumentParser:
-        """Create argument parser from configuration."""
-        if description is None:
-            description = f"Command line interface for {self.app_name}"
-
-        parser = argparse.ArgumentParser(
-            description=description,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-        )
-
-        # Config file argument
-        parser.add_argument(
-            "--config",
-            default=None,
-            help="Path to configuration file (JSON or YAML)",
-        )
-
-        # Verbose/quiet options for log level override
-        parser.add_argument(
-            "-v", "--verbose", action="store_true", help="Enable verbose logging (DEBUG level)"
-        )
-        parser.add_argument(
-            "-q", "--quiet", action="store_true", help="Enable quiet mode (WARNING level only)"
-        )
-
-        # Get CLI parameters
-        cli_params = self.config_manager.get_cli_parameters()
-
-        # Generate arguments from CLI config parameters
-        for param in cli_params:
-            if param.required and param.cli_arg is None:
-                # Positional argument
-                parser.add_argument(param.name, help=param.help)
-            else:
-                # Optional argument
-                kwargs = {
-                    "default": argparse.SUPPRESS,
-                    "help": f"{param.help} (default: {param.default})",
-                }
-
-                # Handle different parameter types
-                if param.choices and param.type_ != bool:
-                    kwargs["choices"] = param.choices
-
-                if param.type_ == int:
-                    kwargs["type"] = int
-                elif param.type_ == float:
-                    kwargs["type"] = float
-                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:
-                    kwargs["type"] = str
-
-                parser.add_argument(param.cli_arg, **kwargs)
-
-        return parser
-
-    def create_config_overrides(self, args: argparse.Namespace) -> dict[str, Any]:
-        """Create configuration overrides from CLI arguments."""
-        cli_params = self.config_manager.get_cli_parameters()
-        overrides = {}
-
-        for param in cli_params:
-            if hasattr(args, param.name):
-                arg_value = getattr(args, param.name)
-                # Add CLI category prefix for override system
-                overrides[f"cli__{param.name}"] = arg_value
-
-        # Handle log level overrides from verbose/quiet flags
-        if hasattr(args, "verbose") and args.verbose:
-            overrides["app__log_level"] = "DEBUG"
-        elif hasattr(args, "quiet") and args.quiet:
-            overrides["app__log_level"] = "WARNING"
-
-        return overrides
-
-    def run_cli(
-        self,
-        main_function: Callable[[ConfigManager], int],
-        description: str = None,
-        validator: Callable[[ConfigManager], bool] = None,
-    ) -> int:
-        """Run the CLI application with error handling.
-
-        Args:
-            main_function: Function that takes ConfigManager and returns exit code
-            description: CLI description
-            validator: Optional function to validate configuration
-
-        Returns:
-            Exit code
-        """
-        logger = None
-
-        try:
-            # Parse command line arguments
-            parser = self.create_argument_parser(description)
-            args = parser.parse_args()
-
-            # Create configuration overrides from CLI arguments
-            cli_overrides = self.create_config_overrides(args)
-
-            # Create new config manager with overrides
-            config_file = args.config if hasattr(args, "config") and args.config else None
-            updated_config = ConfigManager(config_file=config_file, **cli_overrides)
-
-            # Copy categories from original config manager
-            for name, category in self.config_manager._categories.items():
-                updated_config.add_category(name, category)
-
-            # Apply overrides again after copying categories
-            updated_config._apply_kwargs(cli_overrides)
-
-            # Try to get logger if logging is configured
-            try:
-                from .logging import get_logger
-
-                logger = get_logger(f"{self.app_name}.cli")
-                logger.info(f"Starting {self.app_name} CLI")
-                logger.debug(f"Command line arguments: {vars(args)}")
-            except ImportError:
-                pass
-
-            # Validate configuration if validator provided
-            if validator and not validator(updated_config):
-                if logger:
-                    logger.error("Configuration validation failed")
-                else:
-                    print("Configuration validation failed")
-                return 1
-
-            # Run main function
-            return main_function(updated_config)
-
-        except FileNotFoundError as e:
-            if logger:
-                logger.error(f"File not found: {e}")
-                logger.debug("Full traceback:", exc_info=True)
-            else:
-                print(f"Error: {e}")
-                traceback.print_exc()
-            return 1
-
-        except KeyboardInterrupt:
-            if logger:
-                logger.warning("Process interrupted by user")
-            else:
-                print("Process interrupted by user")
-            return 130
-
-        except Exception as e:
-            if logger:
-                logger.error(f"Unexpected error: {e}")
-                logger.debug("Full traceback:", exc_info=True)
-            else:
-                print(f"Unexpected error: {e}")
-                traceback.print_exc()
-            return 1

generic_config_cli_gui/config_framework.py

@@ -1,362 +0,0 @@
-# config_framework/core.py
-"""Generic configuration framework for Python applications."""
-
-import json
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from pathlib import Path
-from textwrap import dedent
-from typing import Any
-
-import yaml
-from pydantic import BaseModel
-
-
-@dataclass
-class ConfigParameter:
-    """Represents a single configuration parameter with all its metadata."""
-
-    name: str
-    default: Any
-    type_: type
-    choices: list[str | bool] = None
-    help: str = ""
-    cli_arg: str = None
-    required: bool = False
-    category: str = "general"
-
-    def __post_init__(self):
-        if self.cli_arg is None and not self.required:
-            self.cli_arg = f"--{self.name}"
-        if self.type_ is bool and self.choices is None:
-            self.choices = [True, False]
-
-
-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.model_fields:
-            param = getattr(self, field_name)
-            if isinstance(param, ConfigParameter):
-                param.category = self.get_category_name()
-                parameters.append(param)
-        return parameters
-
-
-class CliConfigCategory(BaseConfigCategory):
-    """Base class for CLI-specific configuration parameters."""
-
-    def get_category_name(self) -> str:
-        return "cli"
-
-
-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] = {}
-        self._cli_category_name: str = None
-
-        # 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., 'cli', 'app', 'gui')
-            category: Configuration category instance
-        """
-        self._categories[name] = category
-        if isinstance(category, CliConfigCategory):
-            self._cli_category_name = name
-
-    def get_category(self, name: str) -> BaseConfigCategory:
-        """Get a configuration category by name."""
-        return self._categories.get(name)
-
-    def get_cli_category(self) -> BaseConfigCategory | None:
-        """Get the CLI configuration category."""
-        if self._cli_category_name:
-            return self._categories[self._cli_category_name]
-        return None
-
-    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):
-                            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():
-                category_dict[param.name] = param.default
-            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 only CLI parameters."""
-        cli_category = self.get_cli_category()
-        if cli_category:
-            return cli_category.get_parameters()
-        return []
-
-
-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 = param.type_.__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: {param.type_.__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 = param.type_.__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)

generic_config_cli_gui/gui_generator.py

@@ -1,225 +0,0 @@
-# config_framework/gui.py
-"""Generic GUI settings dialog generator for configuration framework."""
-
-import tkinter as tk
-from tkinter import messagebox, ttk
-
-from generic_config_cli_gui.config_framework import ConfigManager, ConfigParameter
-
-
-class ToolTip:
-    """Create a tooltip for a given widget."""
-
-    def __init__(self, widget, text="widget info"):
-        self.widget = widget
-        self.text = text
-        self.tipwindow = None
-        self.id = None
-        self.x = self.y = 0
-
-        self.widget.bind("<Enter>", self.on_enter)
-        self.widget.bind("<Leave>", self.on_leave)
-
-    def on_enter(self, event=None):
-        self.show_tooltip()
-
-    def on_leave(self, event=None):
-        self.hide_tooltip()
-
-    def show_tooltip(self):
-        if self.tipwindow or not self.text:
-            return
-        x, y, cx, cy = self.widget.bbox("insert")
-        x = x + self.widget.winfo_rootx() + 25
-        y = y + cy + self.widget.winfo_rooty() + 25
-        self.tipwindow = tw = tk.Toplevel(self.widget)
-        tw.wm_overrideredirect(True)
-        tw.wm_geometry(f"+{x}+{y}")
-        label = tk.Label(
-            tw,
-            text=self.text,
-            justify=tk.LEFT,
-            background="#ffffe0",
-            relief=tk.SOLID,
-            borderwidth=1,
-            font=("tahoma", "8", "normal"),
-        )
-        label.pack(ipadx=1)
-
-    def hide_tooltip(self):
-        tw = self.tipwindow
-        self.tipwindow = None
-        if tw:
-            tw.destroy()
-
-
-class SettingsDialogGenerator:
-    """Generates settings dialog from ConfigManager."""
-
-    def __init__(self, config_manager: ConfigManager):
-        self.config_manager = config_manager
-
-    def create_settings_dialog(
-        self, parent, title="Settings", config_file="config.yaml"
-    ) -> "GenericSettingsDialog":
-        """Create a settings dialog for the configuration."""
-        return GenericSettingsDialog(parent, self.config_manager, title, config_file)
-
-
-class GenericSettingsDialog:
-    """Generic settings dialog for ConfigManager."""
-
-    def __init__(
-        self, parent, config_manager: ConfigManager, title="Settings", config_file="config.yaml"
-    ):
-        self.parent = parent
-        self.config_manager = config_manager
-        self.config_file = config_file
-        self.result = None
-        self.widgets = {}
-
-        # Create dialog window
-        self.dialog = tk.Toplevel(parent)
-        self.dialog.title(title)
-        self.dialog.geometry("600x500")
-        self.dialog.transient(parent)
-        self.dialog.grab_set()
-
-        # Center the dialog
-        self.dialog.geometry(f"+{int(parent.winfo_rootx() + 50)}+{int(parent.winfo_rooty() + 50)}")
-
-        self._create_widgets()
-
-        # Handle window closing
-        self.dialog.protocol("WM_DELETE_WINDOW", self._on_cancel)
-
-    def _create_widgets(self):
-        """Create the settings dialog widgets."""
-        # Main frame
-        main_frame = ttk.Frame(self.dialog)
-        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
-
-        # Create notebook for tabs
-        self.notebook = ttk.Notebook(main_frame)
-        self.notebook.pack(fill=tk.BOTH, expand=True)
-
-        # Create tabs for each configuration category
-        for category_name, category in self.config_manager._categories.items():
-            self._create_category_tab(category_name, category)
-
-        # Button frame
-        button_frame = ttk.Frame(main_frame)
-        button_frame.pack(fill=tk.X, pady=(10, 0))
-
-        ttk.Button(button_frame, text="OK", command=self._on_ok).pack(side=tk.RIGHT, padx=(5, 0))
-        ttk.Button(button_frame, text="Cancel", command=self._on_cancel).pack(side=tk.RIGHT)
-
-    def _create_category_tab(self, category_name: str, category):
-        """Create a tab for a configuration category."""
-        # Create tab frame
-        tab_frame = ttk.Frame(self.notebook)
-        self.notebook.add(tab_frame, text=category_name.title())
-
-        # Create scrollable frame
-        canvas = tk.Canvas(tab_frame)
-        scrollbar = ttk.Scrollbar(tab_frame, orient="vertical", command=canvas.yview)
-        scrollable_frame = ttk.Frame(canvas)
-
-        scrollable_frame.bind(
-            "<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
-        )
-
-        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
-        canvas.configure(yscrollcommand=scrollbar.set)
-
-        # Add parameters
-        self._add_category_parameters(scrollable_frame, category_name, 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):
-        """Add parameter widgets for a specific category."""
-        row = 0
-        parameters = category.get_parameters()
-
-        for param in parameters:
-            if param.required:
-                # Skip required parameters as they are not configurable in GUI
-                continue
-
-            # Create label
-            label = ttk.Label(parent, text=f"{param.name}:")
-            label.grid(row=row, column=0, sticky="w", padx=5, pady=2)
-
-            # Create appropriate widget based on parameter type
-            widget = self._create_parameter_widget(parent, param)
-            widget.grid(row=row, column=1, sticky="ew", padx=5, pady=2)
-
-            # Add tooltip
-            ToolTip(label, param.help)
-            ToolTip(widget, param.help)
-
-            # Store widget reference
-            self.widgets[f"{category_name}__{param.name}"] = widget
-
-            row += 1
-
-        # Configure column weights
-        parent.columnconfigure(1, weight=1)
-
-    def _create_parameter_widget(self, parent, param: ConfigParameter):
-        """Create appropriate widget for parameter type."""
-        if param.type_ == bool:
-            # Checkbox for boolean values
-            var = tk.BooleanVar(value=param.default)
-            widget = ttk.Checkbutton(parent, variable=var)
-            widget.var = var
-            return widget
-
-        elif param.choices and param.type_ != bool:
-            # Combobox for choices
-            var = tk.StringVar(value=str(param.default))
-            widget = ttk.Combobox(parent, textvariable=var, values=param.choices, state="readonly")
-            widget.var = var
-            return widget
-
-        elif param.type_ == int:
-            # Spinbox for integers
-            var = tk.IntVar(value=param.default)
-            widget = ttk.Spinbox(parent, from_=-999999, to=999999, textvariable=var)
-            widget.var = var
-            return widget
-
-        else:  # str or other types
-            # Entry for strings
-            var = tk.StringVar(value=str(param.default))
-            widget = ttk.Entry(parent, textvariable=var)
-            widget.var = var
-            return widget
-
-    def _on_ok(self):
-        """Handle OK button click."""
-        try:
-            # Update configuration with widget values
-            overrides = {}
-            for key, widget in self.widgets.items():
-                value = widget.var.get()
-                overrides[key] = value
-
-            # Apply overrides to config manager
-            self.config_manager._apply_kwargs(overrides)
-
-            # Save to file
-            self.config_manager.save_to_file(self.config_file)
-
-            self.result = "ok"
-            self.dialog.destroy()
-
-        except Exception as e:
-            messagebox.showerror("Error", f"Failed to save configuration: {e}")
-
-    def _on_cancel(self):
-        """Handle Cancel button click."""
-        self.result = "cancel"
-        self.dialog.destroy()

python_template_project-0.2.0.dist-info/RECORD

@@ -1,27 +0,0 @@
-__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-firewall_handler.py,sha256=qT0dInkeKHulpCQD2x3HH7_lMxz4lwdkIPxEvBSl3No,7336
-main.py,sha256=d6ZpnMxcPBf860gQmuYwPVJg1di6r2CR6gSvFLkAZkk,4448
-generic_config_cli_gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-generic_config_cli_gui/cli_generator.py,sha256=9eN8Lyv3d6bY8LlOoHyAeFAqu1IQFQcQm-zpZ_CjsS4,6396
-generic_config_cli_gui/config_framework.py,sha256=0DttxYz_tnB_qJ6wM-KMwiGXsQzCEr9UbDh84DpxdGM,12514
-generic_config_cli_gui/gui_generator.py,sha256=nB8pRp1eihOG2Cfiz58nY1M6bHfVMGhirW-9NkmhteQ,7628
-python_template_project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_template_project/__main__.py,sha256=JS28LiHoU9Xo4c_RvyLBTDKHqdZRRytJLj6qyrg26mQ,195
-python_template_project/_version.py,sha256=iB5DfB5V6YB5Wo4JmvS-txT42QtmGaWcWp3udRT7zCI,511
-python_template_project/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_template_project/cli/__main__.py,sha256=qnGkoNNbhnvLTA24X8YTEDxRqDbNEAzgjp9Ki_JYIhs,184
-python_template_project/cli/cli.py,sha256=j7LliSLjrntcjDJ5uWpVu8RxriA67xNnytLJYfsrWys,4284
-python_template_project/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_template_project/config/config.py,sha256=nI4Lh2VC4wHnDnJ8e1T0cuzbv1FDMkpGKmtMJ0pMBFY,5804
-python_template_project/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_template_project/core/base.py,sha256=3S_DSPgPom0wCS_tgdEaNpWub0r8GlytmjKtXlIypRA,28045
-python_template_project/core/logging.py,sha256=kfoEWppFh2ihQMFcSXpb4A2mYUnJdYxwXrYScCCAhZo,7015
-python_template_project/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_template_project/gui/__main__.py,sha256=5AaiBxNCAKWcuSQFcQ_lsEQfEsXm6BA5-i5MScdf30c,184
-python_template_project/gui/gui.py,sha256=bh51l_TPt-Oa6zbV9WMJJFJPQKW_-Kz1M-TyCJ3ppao,21794
-python_template_project-0.2.0.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
-python_template_project-0.2.0.dist-info/METADATA,sha256=dhQLBOZC2Z94kIji4GZaTYiO_LYLOlxnUXbVVDSilhs,7948
-python_template_project-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_template_project-0.2.0.dist-info/entry_points.txt,sha256=LmgMiqxIVRdD7gkktVBBR0CR4AhkugqlgifuglkPhtI,148
-python_template_project-0.2.0.dist-info/top_level.txt,sha256=xtUN1Sz5ZjTDsvgfGQpSu4sxObl1HOHgzgb4JAQ1MtA,78
-python_template_project-0.2.0.dist-info/RECORD,,