cli-wizard 1.0.0__py3-none-any.whl

cli_wizard/templates/client.py.j2

@@ -0,0 +1,134 @@
+# AUTO-GENERATED FILE - DO NOT EDIT
+# Generated from OpenAPI specification by cli-wizard
+
+"""HTTP client for API requests."""
+
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from .constants import DEFAULT_BASE_URL, DEFAULT_TIMEOUT, DEFAULT_CA_FILE
+from .logging import log_debug
+
+
+class ApiClient:
+    """HTTP client for making API requests."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        access_token: str | None = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        ca_file: str | None = DEFAULT_CA_FILE,
+        verify_ssl: bool = True,
+        debug: bool = False,
+    ) -> None:
+        """Initialize the API client."""
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.access_token = access_token
+        self.timeout = timeout
+        self.ca_file = ca_file
+        self.verify_ssl = verify_ssl
+        self.debug = debug
+        self.session = requests.Session()
+        self._setup_headers()
+        self._setup_ssl()
+
+    def _setup_headers(self) -> None:
+        """Set up default headers."""
+        self.session.headers["Content-Type"] = "application/json"
+        self.session.headers["Accept"] = "application/json"
+        if self.access_token:
+            self.session.headers["Authorization"] = f"Bearer {self.access_token}"
+
+    def _setup_ssl(self) -> None:
+        """Set up SSL verification with custom CA file if provided."""
+        if not self.verify_ssl:
+            self.session.verify = False
+        elif self.ca_file:
+            ca_path = Path(self.ca_file) if isinstance(self.ca_file, str) else self.ca_file
+            if ca_path and ca_path.exists():
+                self.session.verify = str(ca_path)
+
+    def _url(self, path: str) -> str:
+        """Build full URL from path."""
+        return f"{self.base_url}{path}"
+
+    def _log_request(self, method: str, url: str, params: dict | None = None, json_data: dict | None = None) -> None:
+        """Log request details when debug is enabled."""
+        if not self.debug:
+            return
+        log_debug(f"Request: {method} {url}")
+        if params:
+            log_debug(f"Params: {params}")
+        if json_data:
+            log_debug(f"Body: {json_data}")
+        log_debug(f"Headers: {dict(self.session.headers)}")
+
+    def _log_response(self, response: requests.Response) -> None:
+        """Log response details when debug is enabled."""
+        if not self.debug:
+            return
+        log_debug(f"Response: {response.status_code} {response.reason}")
+        log_debug(f"Response Headers: {dict(response.headers)}")
+        if response.text:
+            log_debug(f"Response Body: {response.text[:1000]}")
+
+    def get(
+        self, path: str, params: dict[str, Any] | None = None
+    ) -> requests.Response:
+        """Make a GET request."""
+        url = self._url(path)
+        self._log_request("GET", url, params=params)
+        response = self.session.get(url, params=params, timeout=self.timeout)
+        self._log_response(response)
+        return response
+
+    def post(
+        self,
+        path: str,
+        json_data: dict[str, Any] | None = None,
+    ) -> requests.Response:
+        """Make a POST request."""
+        url = self._url(path)
+        self._log_request("POST", url, json_data=json_data)
+        response = self.session.post(url, json=json_data, timeout=self.timeout)
+        self._log_response(response)
+        return response
+
+    def put(
+        self,
+        path: str,
+        json_data: dict[str, Any] | None = None,
+    ) -> requests.Response:
+        """Make a PUT request."""
+        url = self._url(path)
+        self._log_request("PUT", url, json_data=json_data)
+        response = self.session.put(url, json=json_data, timeout=self.timeout)
+        self._log_response(response)
+        return response
+
+    def patch(
+        self,
+        path: str,
+        json_data: dict[str, Any] | None = None,
+    ) -> requests.Response:
+        """Make a PATCH request."""
+        url = self._url(path)
+        self._log_request("PATCH", url, json_data=json_data)
+        response = self.session.patch(url, json=json_data, timeout=self.timeout)
+        self._log_response(response)
+        return response
+
+    def delete(
+        self,
+        path: str,
+        json_data: dict[str, Any] | None = None,
+    ) -> requests.Response:
+        """Make a DELETE request."""
+        url = self._url(path)
+        self._log_request("DELETE", url, json_data=json_data)
+        response = self.session.delete(url, json=json_data, timeout=self.timeout)
+        self._log_response(response)
+        return response

cli_wizard/templates/command_group.py.j2

@@ -0,0 +1,161 @@
+# AUTO-GENERATED FILE - DO NOT EDIT
+# Generated from OpenAPI specification by cli-wizard
+
+"""{{ group.name }} commands."""
+
+import json
+import os
+from pathlib import Path
+
+import click
+from typing import Any
+
+from {{ package_name }}.constants import DEFAULT_BASE_URL, DEFAULT_CA_FILE
+from {{ package_name }}.client import ApiClient
+from {{ package_name }}.logging import log_info, log_error, log_debug, set_debug
+from {{ package_name }}.profile import load_profile, get_profile_value
+
+
+def _get_client(
+    base_url: str | None,
+    no_verify_ssl: bool,
+    ca_file: Path | None,
+    debug: bool = False,
+) -> ApiClient:
+    """Create an API client with the given options."""
+    effective_base_url = base_url or os.environ.get("API_BASE_URL") or DEFAULT_BASE_URL
+    effective_ca_file = None if no_verify_ssl else (ca_file or DEFAULT_CA_FILE)
+    access_token = get_profile_value("accessToken")
+    return ApiClient(
+        base_url=effective_base_url,
+        access_token=access_token,
+        ca_file=effective_ca_file,
+        verify_ssl=not no_verify_ssl,
+        debug=debug,
+    )
+
+
+@click.group(name="{{ group.cli_name }}")
+def {{ group.module_name }}() -> None:
+    """{{ group.description }}"""
+{% for op in group.operations %}
+
+
+@{{ group.module_name }}.command(name="{{ op.command_name }}")
+{% for param in op.parameters if param.location == "path" %}
+@click.argument("{{ param.python_name }}"{% if param.click_type != "str" %}, type={{ param.click_type }}{% endif %})
+{% endfor %}
+{% for param in op.parameters if param.location == "query" %}
+{% if param.enum %}
+@click.option("--{{ param.cli_name }}", type=click.Choice([{% for e in param.enum %}"{{ e }}"{% if not loop.last %}, {% endif %}{% endfor %}]){% if param.required %}, required=True{% endif %}{% if param.default is not none %}, default="{{ param.default }}"{% endif %}, help="{{ param.description }}")
+{% else %}
+@click.option("--{{ param.cli_name }}"{% if param.click_type != "str" %}, type={{ param.click_type }}{% endif %}{% if param.required %}, required=True{% endif %}{% if param.default is not none %}, default={{ param.default }}{% endif %}, help="{{ param.description }}")
+{% endif %}
+{% endfor %}
+{% for prop in op.body_properties %}
+@click.option("--{{ prop.cli_name }}"{% if prop.click_type == "bool" %}, is_flag=True{% elif prop.click_type != "str" %}, type={{ prop.click_type }}{% endif %}{% if prop.required %}, required=True{% endif %}, help="{{ prop.description }}")
+{% endfor %}
+@click.option("--profile", "-p", default="default", help="Profile name to use")
+@click.option("--debug", "-d", is_flag=True, help="Enable debug output")
+@click.option("--base-url", "-u", envvar="API_BASE_URL", help="API base URL")
+@click.option("--no-verify-ssl", is_flag=True, default=False, help="Disable SSL certificate verification")
+@click.option("--ca-file", type=click.Path(exists=True, dir_okay=False, path_type=Path), help="CA certificate file for SSL verification")
+def {{ op.function_name }}(
+{% for param in op.parameters if param.location == "path" %}
+    {{ param.python_name }}: {{ param.click_type }},
+{% endfor %}
+{% for param in op.parameters if param.location == "query" %}
+    {{ param.python_name }}: {{ param.click_type }}{% if not param.required %} | None{% endif %},
+{% endfor %}
+{% for prop in op.body_properties %}
+    {{ prop.python_name }}: {{ prop.click_type }}{% if not prop.required %} | None{% endif %},
+{% endfor %}
+    profile: str,
+    debug: bool,
+    base_url: str | None,
+    no_verify_ssl: bool,
+    ca_file: Path | None,
+) -> None:
+    """{{ op.summary or op.operation_id }}"""
+    # Enable debug logging if --debug flag is set
+    set_debug(debug)
+
+    # Load profile
+    load_profile(profile)
+    # Log command execution start
+    cmd_params = {
+{% for param in op.parameters if param.location == "path" %}
+        "{{ param.name }}": {{ param.python_name }},
+{% endfor %}
+{% for param in op.parameters if param.location == "query" %}
+        "{{ param.name }}": {{ param.python_name }},
+{% endfor %}
+{% for prop in op.body_properties %}
+        "{{ prop.name }}": {{ prop.python_name }},
+{% endfor %}
+    }
+    log_debug(f"Executing command '{{ group.cli_name }} {{ op.command_name }}' with params: {cmd_params}")
+
+    client = _get_client(base_url, no_verify_ssl, ca_file, debug)
+{% if op.parameters | selectattr("location", "equalto", "query") | list %}
+
+    params: dict[str, Any] = {}
+{% for param in op.parameters if param.location == "query" %}
+    if {{ param.python_name }} is not None:
+        params["{{ param.name }}"] = {{ param.python_name }}
+{% endfor %}
+{% endif %}
+{% if op.body_properties %}
+
+    body: dict[str, Any] = {}
+{% for prop in op.body_properties %}
+    if {{ prop.python_name }} is not None:
+        body["{{ prop.name }}"] = {{ prop.python_name }}
+{% endfor %}
+{% endif %}
+
+    try:
+{% if op.method == "GET" %}
+{% if op.parameters | selectattr("location", "equalto", "query") | list %}
+        response = client.get("{{ op | url_path }}", params=params)
+{% else %}
+        response = client.get("{{ op | url_path }}")
+{% endif %}
+{% elif op.method == "POST" %}
+{% if op.body_properties %}
+        response = client.post("{{ op | url_path }}", json_data=body)
+{% else %}
+        response = client.post("{{ op | url_path }}")
+{% endif %}
+{% elif op.method == "PUT" %}
+{% if op.body_properties %}
+        response = client.put("{{ op | url_path }}", json_data=body)
+{% else %}
+        response = client.put("{{ op | url_path }}")
+{% endif %}
+{% elif op.method == "PATCH" %}
+{% if op.body_properties %}
+        response = client.patch("{{ op | url_path }}", json_data=body)
+{% else %}
+        response = client.patch("{{ op | url_path }}")
+{% endif %}
+{% elif op.method == "DELETE" %}
+{% if op.body_properties %}
+        response = client.delete("{{ op | url_path }}", json_data=body)
+{% else %}
+        response = client.delete("{{ op | url_path }}")
+{% endif %}
+{% endif %}
+        response.raise_for_status()
+        if response.text:
+            output = json.dumps(response.json(), indent=2)
+            log_debug(f"Command '{{ group.cli_name }} {{ op.command_name }}' completed with output: {output[:500]}")
+            click.echo(output)
+        else:
+            log_debug(f"Command '{{ group.cli_name }} {{ op.command_name }}' completed successfully")
+            click.echo("Success")
+    except Exception as e:
+        log_error(f"Command '{{ group.cli_name }} {{ op.command_name }}' failed: {e}")
+        click.secho(f"Error: {e}", fg="red", err=True)
+        raise SystemExit(1)
+{% endfor %}

cli_wizard/templates/commands_config.py.j2

@@ -0,0 +1,206 @@
+# AUTO-GENERATED FILE - DO NOT EDIT
+# Generated from OpenAPI specification by cli-wizard
+
+"""Config commands for managing CLI profiles."""
+
+import json
+from pathlib import Path
+
+import click
+import yaml
+
+from {{ package_name }}.constants import PROFILE_FILE
+from {{ package_name }}.logging import log_info, log_error, log_warning
+
+
+@click.group(name="config")
+def config() -> None:
+    """Configure the CLI"""
+
+
+@config.command(name="init")
+def config_init() -> None:
+    """Initialize the profile file with default profile."""
+    if PROFILE_FILE.exists():
+        result = {"status": "exists", "path": str(PROFILE_FILE)}
+        click.echo(json.dumps(result, indent=2))
+        return
+
+    try:
+        PROFILE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        default_content = {"default": {}}
+        with open(PROFILE_FILE, "w") as f:
+            yaml.safe_dump(default_content, f, default_flow_style=False)
+        log_info(f"Created profile file: {PROFILE_FILE}")
+        result = {"status": "created", "path": str(PROFILE_FILE)}
+        click.echo(json.dumps(result, indent=2))
+    except (IOError, OSError) as e:
+        log_error(f"Failed to create profile file: {e}")
+        result = {"status": "error", "message": str(e)}
+        click.echo(json.dumps(result, indent=2), err=True)
+        raise SystemExit(1)
+
+
+@config.command(name="list-profiles")
+def config_list_profiles() -> None:
+    """List all available profiles."""
+    if not PROFILE_FILE.exists():
+        result = {"profiles": []}
+        click.echo(json.dumps(result, indent=2))
+        return
+
+    try:
+        with open(PROFILE_FILE) as f:
+            profiles = yaml.safe_load(f) or {}
+    except (yaml.YAMLError, IOError) as e:
+        log_error(f"Failed to load profile file: {e}")
+        result = {"status": "error", "message": str(e)}
+        click.echo(json.dumps(result, indent=2), err=True)
+        raise SystemExit(1)
+
+    result = {"profiles": list(profiles.keys())}
+    click.echo(json.dumps(result, indent=2))
+
+
+@config.command(name="show")
+@click.option("--profile", "-p", default="default", help="Profile name")
+def config_show(profile: str) -> None:
+    """Show all parameters and values for a profile."""
+    if not PROFILE_FILE.exists():
+        click.echo(json.dumps({}, indent=2))
+        return
+
+    try:
+        with open(PROFILE_FILE) as f:
+            profiles = yaml.safe_load(f) or {}
+    except (yaml.YAMLError, IOError) as e:
+        log_error(f"Failed to load profile file: {e}")
+        result = {"status": "error", "message": str(e)}
+        click.echo(json.dumps(result, indent=2), err=True)
+        raise SystemExit(1)
+
+    if profile not in profiles:
+        click.echo(json.dumps({}, indent=2))
+        return
+
+    profile_data = profiles[profile] or {}
+    click.echo(json.dumps(profile_data, indent=2))
+
+
+@config.command(name="get")
+@click.argument("param")
+@click.option("--profile", "-p", default="default", help="Profile name")
+def config_get(param: str, profile: str) -> None:
+    """Get a configuration value from a profile."""
+    if not PROFILE_FILE.exists():
+        result = {"key": param, "value": None}
+        click.echo(json.dumps(result, indent=2))
+        return
+
+    try:
+        with open(PROFILE_FILE) as f:
+            profiles = yaml.safe_load(f) or {}
+    except (yaml.YAMLError, IOError) as e:
+        log_error(f"Failed to load profile file: {e}")
+        result = {"status": "error", "message": str(e)}
+        click.echo(json.dumps(result, indent=2), err=True)
+        raise SystemExit(1)
+
+    if profile not in profiles:
+        result = {"key": param, "value": None}
+        click.echo(json.dumps(result, indent=2))
+        return
+
+    profile_data = profiles[profile] or {}
+    value = profile_data.get(param)
+    result = {"key": param, "value": value}
+    click.echo(json.dumps(result, indent=2))
+
+
+@config.command(name="set")
+@click.argument("param")
+@click.argument("value")
+@click.option("--profile", "-p", default="default", help="Profile name")
+def config_set(param: str, value: str, profile: str) -> None:
+    """Set a configuration value in a profile."""
+    if not PROFILE_FILE.exists():
+        PROFILE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        profiles = {}
+    else:
+        try:
+            with open(PROFILE_FILE) as f:
+                profiles = yaml.safe_load(f) or {}
+        except (yaml.YAMLError, IOError) as e:
+            log_error(f"Failed to load profile file: {e}")
+            result = {"status": "error", "message": str(e)}
+            click.echo(json.dumps(result, indent=2), err=True)
+            raise SystemExit(1)
+
+    if profile not in profiles:
+        profiles[profile] = {}
+
+    # Get old value
+    old_value = profiles[profile].get(param)
+
+    # Try to parse value as JSON for complex types
+    try:
+        parsed_value = json.loads(value)
+    except json.JSONDecodeError:
+        parsed_value = value
+
+    profiles[profile][param] = parsed_value
+
+    try:
+        with open(PROFILE_FILE, "w") as f:
+            yaml.safe_dump(profiles, f, default_flow_style=False)
+        log_info(f"Set '{param}' = '{parsed_value}' in profile '{profile}'")
+        result = {"key": param, "value": parsed_value, "oldValue": old_value}
+        click.echo(json.dumps(result, indent=2))
+    except (IOError, OSError) as e:
+        log_error(f"Failed to save profile file: {e}")
+        result = {"status": "error", "message": str(e)}
+        click.echo(json.dumps(result, indent=2), err=True)
+        raise SystemExit(1)
+
+
+@config.command(name="unset")
+@click.argument("param")
+@click.option("--profile", "-p", default="default", help="Profile name")
+def config_unset(param: str, profile: str) -> None:
+    """Remove a configuration value from a profile."""
+    if not PROFILE_FILE.exists():
+        result = {"key": param, "oldValue": None}
+        click.echo(json.dumps(result, indent=2))
+        return
+
+    try:
+        with open(PROFILE_FILE) as f:
+            profiles = yaml.safe_load(f) or {}
+    except (yaml.YAMLError, IOError) as e:
+        log_error(f"Failed to load profile file: {e}")
+        result = {"status": "error", "message": str(e)}
+        click.echo(json.dumps(result, indent=2), err=True)
+        raise SystemExit(1)
+
+    if profile not in profiles:
+        result = {"key": param, "oldValue": None}
+        click.echo(json.dumps(result, indent=2))
+        return
+
+    profile_data = profiles[profile] or {}
+    old_value = profile_data.get(param)
+
+    if param in profile_data:
+        del profiles[profile][param]
+        try:
+            with open(PROFILE_FILE, "w") as f:
+                yaml.safe_dump(profiles, f, default_flow_style=False)
+            log_info(f"Removed '{param}' from profile '{profile}'")
+        except (IOError, OSError) as e:
+            log_error(f"Failed to save profile file: {e}")
+            result = {"status": "error", "message": str(e)}
+            click.echo(json.dumps(result, indent=2), err=True)
+            raise SystemExit(1)
+
+    result = {"key": param, "oldValue": old_value}
+    click.echo(json.dumps(result, indent=2))

cli_wizard/templates/commands_init.py.j2

@@ -0,0 +1,14 @@
+# AUTO-GENERATED FILE - DO NOT EDIT
+# Generated from OpenAPI specification by cli-wizard
+
+"""Generated CLI commands."""
+
+{% for tag, group in groups.items() %}
+from .{{ group.module_name }} import {{ group.module_name }}
+{% endfor %}
+
+__all__ = [
+{% for tag, group in groups.items() %}
+    "{{ group.module_name }}",
+{% endfor %}
+]

cli_wizard/templates/constants.py.j2

@@ -0,0 +1,67 @@
+# AUTO-GENERATED FILE - DO NOT EDIT
+# Generated from OpenAPI specification by cli-wizard
+
+"""Constants for the generated CLI."""
+
+import os
+from pathlib import Path
+
+
+def _read_version() -> str:
+    """Read version from VERSION file."""
+    version_file = Path(__file__).parent.parent.parent / "VERSION"
+    if version_file.exists():
+        return version_file.read_text().strip()
+    return "0.0.0"
+
+
+__version__ = _read_version()
+
+# Main directory for CLI data (config, cache, etc.)
+MAIN_DIR = Path(os.path.expandvars("{{ main_dir }}"))
+
+# Profile configuration
+PROFILE_FILE = Path(os.path.expandvars("{{ config.ProfileFile | default('#[MainDir]/profiles.yaml') }}"))
+
+DEFAULT_BASE_URL = "{{ config.DefaultBaseUrl | default('http://localhost:8080') }}"
+DEFAULT_TIMEOUT = {{ config.Timeout | default(30) }}
+{% if ca_file_name %}
+DEFAULT_CA_FILE = Path(__file__).parent / "resources" / "{{ ca_file_name }}"
+{% else %}
+DEFAULT_CA_FILE = None
+{% endif %}
+
+# Splash screen configuration
+{% if splash_file_name %}
+SPLASH_ENABLED = True
+SPLASH_FILE = Path(__file__).parent / "resources" / "{{ splash_file_name }}"
+SPLASH_COLOR = "{{ config.SplashColor | default('#FFFFFF') }}"
+{% else %}
+SPLASH_ENABLED = False
+SPLASH_FILE = None
+SPLASH_COLOR = None
+{% endif %}
+
+# Log configuration
+LOG_LEVEL = "{{ config.LogLevel | default('INFO') }}"
+LOG_FORMAT = "{{ config.LogFormat | default('%(asctime)s [%(levelname)s] %(message)s') }}"
+LOG_TIMESTAMP_FORMAT = "{{ config.LogTimestampFormat | default('%Y-%m-%dT%H:%M:%S') }}"
+LOG_TIMEZONE = "{{ config.LogTimezone | default('UTC') }}"
+{% if config.LogFile %}
+LOG_FILE = Path(os.path.expandvars("{{ config.LogFile }}"))
+{% else %}
+LOG_FILE = None
+{% endif %}
+LOG_ROTATION_TYPE = "{{ config.LogRotationType | default('days') }}"
+LOG_ROTATION_SIZE_MB = {{ config.LogRotationSize | default(10) }}
+LOG_ROTATION_DAYS = {{ config.LogRotationDays | default(30) }}
+LOG_ROTATION_BACKUP_COUNT = {{ config.LogRotationBackupCount | default(5) }}
+
+# Log color configuration
+LOG_COLOR_STYLE = "{{ config.LogColorStyle | default('level') }}"
+LOG_COLORS = {
+    "DEBUG": "{{ config.LogColorDebug | default('#808080') }}",
+    "INFO": "{{ config.LogColorInfo | default('#00FF00') }}",
+    "WARNING": "{{ config.LogColorWarning | default('#FFFF00') }}",
+    "ERROR": "{{ config.LogColorError | default('#FF0000') }}",
+}