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

config_cli_gui/gui_generator.py

@@ -0,0 +1,225 @@
+# config_framework/gui.py
+"""Generic GUI settings dialog generator for configuration framework."""
+
+import tkinter as tk
+from tkinter import messagebox, ttk
+
+from 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()

config_cli_gui-0.0.2.dist-info/METADATA

@@ -0,0 +1,282 @@
+Metadata-Version: 2.4
+Name: config-cli-gui
+Version: 0.0.2
+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"
+Requires-Dist: coverage>=7.8.2; extra == "dev"
+Requires-Dist: flake8>=7.2.0; extra == "dev"
+Requires-Dist: black>=25.1.0; extra == "dev"
+Requires-Dist: isort>=6.0.1; extra == "dev"
+Requires-Dist: pytest-cov>=6.1.1; extra == "dev"
+Requires-Dist: mypy>=1.16.0; extra == "dev"
+Requires-Dist: gitchangelog>=3.0.4; extra == "dev"
+Requires-Dist: pyinstaller>=5.8; extra == "dev"
+Requires-Dist: pre-commit>=4.2.0; extra == "dev"
+Requires-Dist: ruff>=0.11.13; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6.1; extra == "docs"
+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
+
+Provides a generic configuration framework that automatically generates both command-line interfaces and GUI settings dialogs from configuration parameters. 
+
+[![Github CI Status](https://github.com/pamagister/config-cli-gui/actions/workflows/main.yml/badge.svg)](https://github.com/pamagister/config-cli-gui/actions)
+[![GitHub release](https://img.shields.io/github/v/release/pamagister/config-cli-gui)](https://github.com/pamagister/config-cli-gui/releases)
+[![Read the Docs](https://readthedocs.org/projects/config-cli-gui/badge/?version=stable)](https://config-cli-gui.readthedocs.io/en/stable/)
+[![License](https://img.shields.io/github/license/pamagister/config-cli-gui)](https://github.com/pamagister/config-cli-gui/blob/main/LICENSE)
+[![GitHub issues](https://img.shields.io/github/issues/pamagister/config-cli-gui)](https://github.com/pamagister/config-cli-gui/issues)
+[![PyPI](https://img.shields.io/pypi/v/config-cli-gui)](https://pypi.org/project/config-cli-gui/)
+[![Downloads](https://pepy.tech/badge/config-cli-gui)](https://pepy.tech/project/config-cli-gui/)
+
+
+`config-cli-gui` is a Python library designed to streamline the management of application configurations, 
+generating command-line interfaces (CLIs), and dynamically creating graphical user interface (GUI) settings dialogs 
+from a single source of truth. It leverages Pydantic for robust parameter definition and offers 
+powerful features for consistent configuration across different application entry points.
+
+---
+
+## 🚀 Installation
+
+You can install `config-cli-gui` using pip:
+
+```bash
+pip install config-cli-gui
+````
+
+---
+
+## ✨ Features
+
+  * **Single Source of Truth**: Define all your application parameters in one place using simple, dataclass-like structures based on Pydantic's `BaseModel`. This ensures consistency and reduces errors across your application.
+  * **Categorized Configuration**: Organize your parameters into logical categories (e.g., `cli`, `app`, `gui`) for better structure and maintainability.
+  * **Dynamic CLI Generation**: Automatically generate `argparse`-compatible command-line arguments directly from your defined configuration parameters, including help texts, types, and choices.
+  * **Config File Management**: Easily load and save configurations from/to YAML or JSON files, allowing users to customize default settings.
+  * **GUI Settings Dialogs**: Dynamically create Tkinter-based settings dialogs for your application, allowing users to intuitively modify configuration parameters via a graphical interface.
+  * **Documentation Generation**: Generate detailed Markdown documentation for both your CLI options and all configuration parameters, keeping your user guides always up-to-date with your codebase.
+  * **Override System**: Supports robust overriding of configuration values via configuration files and command-line arguments, with clear precedence.
+
+---
+
+## 📚 Usage
+
+### 1\. Define Your Configuration
+
+Start by defining your application's configuration parameters in a central `config.py` file within your project. You will inherit from `config-cli-gui`'s `GenericConfigManager` and `BaseConfigCategory`.
+
+```python
+# my_project/config.py
+from config_cli_gui.config import ConfigParameter, GenericConfigManager, BaseConfigCategory
+from pydantic import Field # Make sure pydantic is installed
+
+class MyCliConfig(BaseConfigCategory):
+    """CLI-specific parameters for MyProject."""
+    input_path: ConfigParameter = ConfigParameter(
+        name="input_path",
+        default="",
+        type_=str,
+        help="Path to the input file or directory",
+        required=True,
+        cli_arg=None # Positional argument
+    )
+    output_dir: ConfigParameter = ConfigParameter(
+        name="output_dir",
+        default="./output",
+        type_=str,
+        help="Directory for output files",
+        cli_arg="--output"
+    )
+    dry_run: ConfigParameter = ConfigParameter(
+        name="dry_run",
+        default=False,
+        type_=bool,
+        help="Perform a dry run without making actual changes",
+        cli_arg="--dry-run"
+    )
+
+class MyAppConfig(BaseConfigCategory):
+    """Application-wide settings."""
+    log_level: ConfigParameter = ConfigParameter(
+        name="log_level",
+        default="INFO",
+        type_=str,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        help="Logging verbosity level"
+    )
+    max_threads: ConfigParameter = ConfigParameter(
+        name="max_threads",
+        default=4,
+        type_=int,
+        help="Maximum number of processing threads"
+    )
+
+class MyGuiConfig(BaseConfigCategory):
+    """GUI-specific settings."""
+    theme: ConfigParameter = ConfigParameter(
+        name="theme",
+        default="dark",
+        type_=str,
+        choices=["light", "dark", "system"],
+        help="GUI theme"
+    )
+    window_size: ConfigParameter = ConfigParameter(
+        name="window_size",
+        default="800x600",
+        type_=str,
+        help="Initial GUI window size"
+    )
+
+class ProjectConfigManager(GenericConfigManager):
+    """Main configuration manager for MyProject."""
+    cli: MyCliConfig = Field(default_factory=MyCliConfig)
+    app: MyAppConfig = Field(default_factory=MyAppConfig)
+    gui: MyGuiConfig = Field(default_factory=MyGuiConfig)
+
+    def __init__(self, config_file: str | None = None, **kwargs):
+        # Dynamically register categories for the generic manager
+        self.__class__.add_config_category("cli", MyCliConfig)
+        self.__class__.add_config_category("app", MyAppConfig)
+        self.__class__.add_config_category("gui", MyGuiConfig)
+        super().__init__(config_file, **kwargs)
+
+```
+
+### 2\. Generate CLI
+
+Use the generic CLI functions to parse command-line arguments based on your defined `CliConfig`.
+
+```python
+# my_project/cli.py
+import argparse
+from my_project.config import ProjectConfigManager
+from config_cli_gui.cli import create_argument_parser, create_config_overrides_from_args
+
+def parse_my_args():
+    # Define any project-specific hardcoded CLI args (e.g., --version)
+    extra_cli_args = {
+        "--version": {"action": "version", "version": "MyProject 1.0.0", "help": "Show program's version number and exit."}
+    }
+
+    parser = create_argument_parser(
+        config_manager_class=ProjectConfigManager,
+        description="MyProject CLI application",
+        epilog="""
+Examples:
+  python -m my_project.cli my_input.txt --output ./results
+  python -m my_project.cli --config custom.yaml another_input.csv
+        """,
+        cli_category_name="cli", # The name of your CLI config category
+        extra_arguments=extra_cli_args
+    )
+    return parser.parse_args()
+
+def main_cli():
+    args = parse_my_args()
+
+    # Map generic flags like verbose/quiet to specific log levels if desired
+    log_level_map = {
+        "verbose": "DEBUG", # Assuming you added a --verbose flag in extra_cli_args
+        "quiet": "WARNING"  # Assuming you added a --quiet flag
+    }
+
+    cli_overrides = create_config_overrides_from_args(
+        args,
+        config_manager_class=ProjectConfigManager,
+        cli_category_name="cli",
+        log_level_map=log_level_map
+    )
+
+    # Initialize your project's configuration
+    config = ProjectConfigManager(
+        config_file=args.config if hasattr(args, "config") and args.config else None,
+        **cli_overrides
+    )
+
+    print(f"Input Path: {config.cli.input_path.default}")
+    print(f"Output Directory: {config.cli.output_dir.default}")
+    print(f"Dry Run: {config.cli.dry_run.default}")
+    print(f"Log Level: {config.app.log_level.default}")
+    # ... your application logic using 'config'
+
+if __name__ == "__main__":
+    main_cli()
+```
+
+### 3\. Integrate GUI Settings Dialog
+
+The `SettingsDialog` from `config-cli-gui` (or your project's adapted version) can be used to easily create a settings window.
+
+```python
+# my_project/gui.py (Simplified example)
+import tkinter as tk
+from my_project.config import ProjectConfigManager
+from config_cli_gui.gui_settings import SettingsDialog # Assuming gui_settings is part of the generic lib or adapted
+
+def open_settings_window(parent_root, config_manager: ProjectConfigManager):
+    dialog = SettingsDialog(parent_root, config_manager)
+    parent_root.wait_window(dialog.dialog)
+    # After dialog closes, config_manager will have updated values if 'OK' was clicked
+    print("Settings updated or cancelled.")
+    print(f"New GUI Theme: {config_manager.gui.theme.default}")
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    root.withdraw() # Hide main window for this example
+    
+    # Initialize your project's config manager
+    project_config = ProjectConfigManager() 
+    
+    open_settings_window(root, project_config)
+    
+    root.destroy()
+```
+
+### 4\. Generate Documentation and Default Config
+
+Use the static methods on your `ProjectConfigManager` to generate `config.yaml`, `cli.md`, and `config.md` files.
+
+```python
+# scripts/generate_docs.py (or similar script in your project)
+from my_project.config import ProjectConfigManager
+import os
+
+# Define output paths
+output_dir = "docs/generated"
+os.makedirs(output_dir, exist_ok=True)
+
+config_file_path = "config.yaml" # At the project root or similar
+cli_doc_path = os.path.join(output_dir, "cli.md")
+config_doc_path = os.path.join(output_dir, "config.md")
+
+print(f"Generating default config to: {config_file_path}")
+ProjectConfigManager.generate_default_config_file(config_file_path)
+
+print(f"Generating general config documentation to: {config_doc_path}")
+ProjectConfigManager.generate_config_markdown_doc(config_doc_path)
+
+print(f"Generating CLI documentation to: {cli_doc_path}")
+ProjectConfigManager.generate_cli_markdown_doc(
+    output_file=cli_doc_path,
+    cli_category_name="cli", # Ensure this matches your CLI config category
+    cli_entry_point="python -m my_project.cli" # Your project's actual CLI entry point
+)
+
+print("Documentation and default config generation complete.")
+```
+
+By following this structure, `config-cli-gui` provides a robust and maintainable foundation for your application's configuration needs.

config_cli_gui-0.0.2.dist-info/RECORD

@@ -0,0 +1,26 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+main.py,sha256=PbF_c10dnW7FCmtNtKwuABfLh5tfDWfnhZwA0Udb7bQ,4430
+config_cli_gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+config_cli_gui/_version.py,sha256=wO7XWlZte1hxA4mMvRc6zhNdGm74Nhhn2bfWRAxaKbI,511
+config_cli_gui/cli_generator.py,sha256=UkRbpAxQA6Wrs7omSk5SUwE_ci3c1BXsYTN5d3h2skU,6380
+config_cli_gui/config_framework.py,sha256=0DttxYz_tnB_qJ6wM-KMwiGXsQzCEr9UbDh84DpxdGM,12514
+config_cli_gui/gui_generator.py,sha256=K5kDsFzo0pZPaCLaas3FUateiHwPjjrvF9hiT8QhftM,7620
+config_cli_gui-0.0.2.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+example_project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+example_project/__main__.py,sha256=m9ddpnP0vLdye1PBnWaOi-KFumFVmqAVaJF4SAjEueY,186
+example_project/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+example_project/cli/__main__.py,sha256=qnGkoNNbhnvLTA24X8YTEDxRqDbNEAzgjp9Ki_JYIhs,184
+example_project/cli/cli.py,sha256=gG16WypUSfMfn0vs0w2uq3PlmQdgHDm_Iw_-cJcTMlU,4213
+example_project/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+example_project/config/config.py,sha256=QLQUF0HFfbIh2iDjnPPlNimmS75JahQIGQFXrE9VUfM,5787
+example_project/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+example_project/core/base.py,sha256=uYKbnkfM6lY7IN_jEewJKsRxjMJ0UMnL4r5bMEi6xTQ,27036
+example_project/core/logging.py,sha256=aadgQxw_0ErQ4Ruupv7JtbS09vcNK70GDTNzgcGwook,6971
+example_project/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+example_project/gui/__main__.py,sha256=5AaiBxNCAKWcuSQFcQ_lsEQfEsXm6BA5-i5MScdf30c,184
+example_project/gui/gui.py,sha256=8zwYnfr3SSO2v1PAWfZbf3qazd60Tc6wAPUYsMoK418,21705
+config_cli_gui-0.0.2.dist-info/METADATA,sha256=-OkyKO7wXBjIUgQYhQUBboLp_Nl2VdUepje4TbnKhu0,11311
+config_cli_gui-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+config_cli_gui-0.0.2.dist-info/entry_points.txt,sha256=T-j8vHWuq5H3v0j5kMBJ93FqNNEE84gDCL5fRLDiGzQ,112
+config_cli_gui-0.0.2.dist-info/top_level.txt,sha256=uV2Y_uzKV2W2AUm1BxjlrIyNxuAXYxYDMtY3BELGtNU,45
+config_cli_gui-0.0.2.dist-info/RECORD,,

config_cli_gui-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

config_cli_gui-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+config-cli-gui = config_cli_gui.cli.cli:main
+config-cli-gui-gui = config_cli_gui.gui.gui:main

config_cli_gui-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

config_cli_gui-0.0.2.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+__init__
+config_cli_gui
+example_project
+main

example_project/__main__.py

@@ -0,0 +1,8 @@
+"""Entry point for config_cli_gui."""
+
+import sys  # pragma: no cover
+
+from .cli.cli import main  # pragma: no cover
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

example_project/cli/__main__.py

@@ -0,0 +1,8 @@
+"""CLI entry point for project_name."""
+
+import sys  # pragma: no cover
+
+from .cli import main  # pragma: no cover
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())