cmdbox-cli 1.0.0__py3-none-any.whl

cmdbox/cli/commands/tag_crud.py

@@ -0,0 +1,277 @@
+import logging
+from typing import Annotated
+
+import typer
+
+from cmdbox import container
+from cmdbox.cli.common.errors import make_cli_guard
+from cmdbox.cli.completions.fields import tag_editable_field_options, tag_field_options
+from cmdbox.cli.completions.tags import complete_tag_names
+from cmdbox.cli.handlers import tag_handlers
+
+app = typer.Typer(no_args_is_help=True)
+
+cli_guard = make_cli_guard(container.get_console)
+
+log = logging.getLogger(__name__)
+
+
+@app.command("add")
+@cli_guard
+def add(
+    name: Annotated[
+        str,
+        typer.Argument(help="The name of the tag.", autocompletion=complete_tag_names),
+    ] = None,
+    description: Annotated[
+        str, typer.Argument(help="A description of the tag.")
+    ] = None,
+    interactive: Annotated[
+        bool,
+        typer.Option(
+            "--interactive",
+            "-i",
+            is_flag=True,
+            help="Prompt for tag details interactively.",
+        ),
+    ] = False,
+) -> None:
+    """
+    Adds a new tag with a name and description. The tag can be created in
+    interactive if no options are provided or the `--interactive` flag is
+    used.
+    """
+    log.debug(
+        "tag.add called. name=%s, description=%s, interactive=%s",
+        name,
+        description,
+        interactive,
+    )
+    add_tag_args = tag_handlers.AddTagArgs(
+        name=name, description=description, interactive=interactive
+    )
+    tag_handlers.run_add_tag(
+        args=add_tag_args,
+        get_tag_services=container.get_tag_services,
+        get_console=container.get_console,
+    )
+
+
+@app.command("get")
+@cli_guard
+def get(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the tag to retrieve.", autocompletion=complete_tag_names
+        ),
+    ],
+) -> None:
+    """
+    Gets and displays a saved tag under the provided name.
+    """
+    log.debug("tag.get called. name=%s", name)
+    tag_handlers.run_get_tag(
+        name=name,
+        get_tag_services=container.get_tag_services,
+        get_console=container.get_console,
+    )
+
+
+@app.command("update")
+@cli_guard
+def update(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the tag to update.", autocompletion=complete_tag_names
+        ),
+    ],
+    description: Annotated[
+        str,
+        typer.Option("--description", "-d", help="The new description of the tag."),
+    ] = None,
+    new_name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="The new name of the tag."),
+    ] = None,
+    set_: Annotated[
+        list[str],
+        typer.Option(
+            "--set",
+            "-s",
+            help="A list of key=value pairs to update.",
+            autocompletion=tag_editable_field_options,
+        ),
+    ] = None,
+    edit_mode: Annotated[
+        bool,
+        typer.Option("--edit", "-e", help="Edit mode."),
+    ] = False,
+    edit_fields: Annotated[
+        str,
+        typer.Option(
+            "--edit-fields",
+            "-ef",
+            help="A list of fields to be edited in edit mode, separated by commas. Defaults to all fields.",
+        ),
+    ] = None,
+) -> None:
+    """
+    Updates an existing tag with the provided options. Each field can be updated
+    individually or in bulk using the `--set` option. Using the `--edit` option enables
+    editing the already stored values in an interactive mode.
+    """
+    log.debug(
+        "tag.update called. name=%s, description=%s, new_name=%s, set_pairs=%s, edit_mode=%s, edit_fields=%s",
+        name,
+        description,
+        new_name,
+        set_,
+        edit_mode,
+        edit_fields,
+    )
+    tag_handlers.run_update_tag(
+        name=name,
+        description=description,
+        new_name=new_name,
+        set_pairs=set_,
+        edit_mode=edit_mode,
+        edit_fields=edit_fields,
+        get_tag_services=container.get_tag_services,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+    )
+
+
+app.command("edit", hidden=True)(update)
+
+
+@app.command("list")
+@cli_guard
+def list_tags(
+    order: Annotated[
+        str,
+        typer.Option(
+            "--order",
+            "-o",
+            help="The field to order the results by.",
+            autocompletion=tag_field_options,
+        ),
+    ] = "name",
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-l", help="The maximum number of results to return."),
+    ] = 10,
+    fields: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--field",
+            "-f",
+            help="The fields to display in the results list.",
+            autocompletion=tag_field_options,
+        ),
+    ] = None,
+) -> None:
+    """
+    Displays all stored tags in a list format. The number of results can be limited
+    with the `--limit` option. The output fields can be customized with the `--field` option.
+    """
+    log.debug("tag.list called. order=%s, limit=%s, fields=%s", order, limit, fields)
+    tag_handlers.run_list_tags(
+        limit=limit,
+        fields=fields,
+        order_by=order,
+        get_tag_services=container.get_tag_services,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+        get_display_field_resolver=container.get_tag_display_field_resolver,
+    )
+
+
+app.command("ls", hidden=True)(list_tags)
+
+
+@app.command("search")
+@cli_guard
+def search(
+    term: Annotated[
+        str,
+        typer.Argument(
+            help="The search term to use.", autocompletion=complete_tag_names
+        ),
+    ],
+    limit: Annotated[
+        int, typer.Option(help="The maximum number of results to return.")
+    ] = 10,
+    search_fields: Annotated[
+        list[str],
+        typer.Option(
+            "--in",
+            "-i",
+            help="The fields to search within.",
+            autocompletion=tag_field_options,
+        ),
+    ] = None,
+    fields: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--field",
+            "-f",
+            help="The field(s) to display in the results list. Defaults to all fields.",
+            autocompletion=tag_field_options,
+        ),
+    ] = None,
+) -> None:
+    """
+    Searches the database for tags matching the provided search term. The search fields
+    can be customized with the `--in` option. The output fields can be customized with the
+    `--field` option.
+    """
+    log.debug(
+        "tag.search called. term=%s, limit=%s, search_fields=%s, fields=%s",
+        term,
+        limit,
+        search_fields,
+        fields,
+    )
+    tag_handlers.run_search_tags(
+        term=term,
+        limit=limit,
+        search_fields=search_fields,
+        fields=fields,
+        get_tag_services=container.get_tag_services,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+        get_display_field_resolver=container.get_tag_display_field_resolver,
+        get_search_field_resolver=container.get_tag_search_field_resolver,
+    )
+
+
+app.command("find", hidden=True)(search)
+
+
+@app.command("delete")
+@cli_guard
+def delete(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the tag to delete.", autocompletion=complete_tag_names
+        ),
+    ],
+) -> None:
+    """
+    Deletes the tag stored under the provided name.
+    """
+    log.debug("tag.delete called. name=%s", name)
+    tag_handlers.run_delete_tag(
+        name=name,
+        get_tag_services=container.get_tag_services,
+        get_console=container.get_console,
+    )
+
+
+app.command("del", hidden=True)(delete)
+app.command("rm", hidden=True)(delete)
+app.command("remove", hidden=True)(delete)

cmdbox/cli/commands/variable_crud.py

@@ -0,0 +1,349 @@
+import logging
+from typing import Annotated
+
+import typer
+
+from cmdbox import container
+from cmdbox.cli.common.errors import make_cli_guard
+from cmdbox.cli.completions.fields import variable_field_options
+from cmdbox.cli.completions.variables import complete_variable_names
+from cmdbox.cli.completions.tags import complete_tag_names
+from cmdbox.cli.handlers import variable_handlers
+
+app = typer.Typer(no_args_is_help=True)
+
+cli_guard = make_cli_guard(container.get_console)
+
+log = logging.getLogger(__name__)
+
+
+@app.command("add")
+@cli_guard
+def add(
+    name: Annotated[str, typer.Argument(help="The name of the variable.")] = None,
+    value: Annotated[str, typer.Argument(help="The value of the variable.")] = None,
+    tags: Annotated[
+        list[str],
+        typer.Option(
+            "--tags",
+            "-t",
+            help="A list of tags to associate with the variable, separated by commas.",
+            autocompletion=complete_tag_names,
+        ),
+    ] = None,
+    interactive: Annotated[
+        bool,
+        typer.Option("--interactive", "-i", is_flag=True, help="Interactive mode."),
+    ] = False,
+) -> None:
+    """
+    Adds a new variable with the specified name, value, and tags. The variable
+    can be created in interactive mode if no options are provided or the `--interactive`
+    flag is used.
+    """
+    log.debug(
+        "var.add called. name=%s, value=%s, tags=%s, interactive=%s",
+        name,
+        value,
+        tags,
+        interactive,
+    )
+    add_var_args = variable_handlers.AddVariableArgs(
+        name=name, value=value, tags=tags, interactive=interactive
+    )
+    variable_handlers.run_add_variable(
+        args=add_var_args,
+        get_var_services=container.get_variable_services,
+        get_tag_services=container.get_tag_services,
+        get_console=container.get_console,
+    )
+
+
+@app.command("get")
+@cli_guard
+def get(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the variable to retrieve.",
+            autocompletion=complete_variable_names,
+        ),
+    ],
+) -> None:
+    """
+    Retrieves and displays the variable stored under the provided name.
+    """
+    log.debug("var.get called. name=%s", name)
+    variable_handlers.run_get_variable(
+        name=name,
+        get_var_services=container.get_variable_services,
+        get_console=container.get_console,
+    )
+
+
+@app.command("update")
+@cli_guard
+def update(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the variable to update.",
+            autocompletion=complete_variable_names,
+        ),
+    ],
+    value: Annotated[str, typer.Option("--value", "-v", help="The new value.")] = None,
+    new_name: Annotated[str, typer.Option("--name", "-n", help="The new name.")] = None,
+    set_: Annotated[
+        list[str],
+        typer.Option(
+            "--set",
+            "-s",
+            help="A list of key=value pairs to update.",
+            autocompletion=variable_field_options,
+        ),
+    ] = None,
+    edit_mode: Annotated[
+        bool,
+        typer.Option("--edit", "-e", help="Edit mode."),
+    ] = False,
+    edit_fields: Annotated[
+        str,
+        typer.Option(
+            "--edit-fields",
+            "-ef",
+            help="A list of fields to be edited in edit mode, separated by commas. Defaults to all fields.",
+        ),
+    ] = None,
+) -> None:
+    """
+    Updates an existing variable with the provided options. Each field can be updated
+    individually or in bulk using the `--set` option. Using the `--edit` option enables
+    editing the already stored values in an interactive mode.
+    """
+    log.debug(
+        "var.update called. name=%s, value=%s, new_name=%s, set_pairs=%s, edit_mode=%s, edit_fields=%s",
+        name,
+        value,
+        new_name,
+        set_,
+        edit_mode,
+        edit_fields,
+    )
+    variable_handlers.run_update_variable(
+        name=name,
+        value=value,
+        new_name=new_name,
+        set_pairs=set_,
+        edit_mode=edit_mode,
+        edit_fields=edit_fields,
+        get_var_services=container.get_variable_services,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+    )
+
+
+app.command("edit", hidden=True)(update)
+
+
+@app.command("list")
+@cli_guard
+def list_vars(
+    order: Annotated[
+        str,
+        typer.Option(
+            "--order",
+            "-o",
+            help="The field to order the results by.",
+            autocompletion=variable_field_options,
+        ),
+    ] = "name",
+    tags: Annotated[
+        list[str],
+        typer.Option(
+            "--tag",
+            "-t",
+            help="The tags to filter by.",
+            autocompletion=complete_tag_names,
+        ),
+    ] = None,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", "-l", help="The maximum number of results to return."),
+    ] = 10,
+    fields: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--field",
+            "-f",
+            help="The fields to display in the results list.",
+            autocompletion=variable_field_options,
+        ),
+    ] = None,
+) -> None:
+    """
+    Displays all stored variables in a list format. The number of results can be limited
+    with the `--limit` option. The output fields can be customized with the `--field` option.
+    """
+    log.debug(
+        "var.list called. order=%s, tags=%s, limit=%s, fields=%s",
+        order,
+        tags,
+        limit,
+        fields,
+    )
+    variable_handlers.run_list_variables(
+        order_by=order,
+        tags=tags,
+        limit=limit,
+        fields=fields,
+        get_var_services=container.get_variable_services,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+        get_display_field_resolver=container.get_variable_display_field_resolver,
+    )
+
+
+app.command("ls", hidden=True)(list_vars)
+
+
+@app.command("search")
+@cli_guard
+def search(
+    term: Annotated[str, typer.Argument(help="The search term to use.")],
+    limit: Annotated[
+        int, typer.Option(help="The maximum number of results to return.")
+    ] = 10,
+    search_fields: Annotated[
+        list[str],
+        typer.Option(
+            "--in",
+            "-i",
+            help="The fields to search within.",
+            autocompletion=variable_field_options,
+        ),
+    ] = None,
+    fields: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--field",
+            "-f",
+            help="The field(s) to display in the results list. Defaults to all fields.",
+            autocompletion=variable_field_options,
+        ),
+    ] = None,
+) -> None:
+    """
+    Searches the database for variables matching the provided search term. The search fields
+    can be customized with the `--in` option. The output fields can be customized with the
+    `--field` option.
+    """
+    log.debug(
+        "var.search called. term=%s, limit=%s, search_fields=%s, fields=%s",
+        term,
+        limit,
+        search_fields,
+        fields,
+    )
+    variable_handlers.run_search_variables(
+        term=term,
+        limit=limit,
+        search_fields=search_fields,
+        fields=fields,
+        get_var_services=container.get_variable_services,
+        get_settings=container.get_settings,
+        get_console=container.get_console,
+        get_display_field_resolver=container.get_variable_display_field_resolver,
+        get_search_field_resolver=container.get_variable_search_field_resolver,
+    )
+
+
+app.command("find", hidden=True)(search)
+
+
+@app.command("delete")
+@cli_guard
+def delete(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the variable to delete.",
+            autocompletion=complete_variable_names,
+        ),
+    ],
+) -> None:
+    """
+    Deletes the variable stored under the provided name.
+    """
+    log.debug("var.delete called. name=%s", name)
+    variable_handlers.run_delete_variable(
+        name=name,
+        get_var_services=container.get_variable_services,
+        get_console=container.get_console,
+    )
+
+
+app.command("del", hidden=True)(delete)
+app.command("rm", hidden=True)(delete)
+app.command("remove", hidden=True)(delete)
+
+
+@app.command("tag")
+@cli_guard
+def add_tags(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the command to tag.",
+            autocompletion=complete_variable_names,
+        ),
+    ],
+    tags: Annotated[
+        list[str],
+        typer.Argument(
+            help="The tags to add to the command.", autocompletion=complete_tag_names
+        ),
+    ] = None,
+) -> None:
+    """
+    Adds the provided tags to the command stored under the provided alias. Tags must
+    be existing.
+    """
+    log.debug("var.tag.add called. name=%s, tags=%s", name, tags)
+    variable_handlers.run_attach_tags(
+        name=name,
+        tag_names=tags,
+        get_var_services=container.get_variable_services,
+        get_tag_services=container.get_tag_services,
+        get_console=container.get_console,
+    )
+
+
+@app.command("untag")
+@cli_guard
+def remove_tags(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="The name of the command to untag.",
+            autocompletion=complete_variable_names,
+        ),
+    ],
+    tags: Annotated[
+        list[str],
+        typer.Argument(
+            help="The tags to remove from the command.",
+            autocompletion=complete_tag_names,
+        ),
+    ] = None,
+) -> None:
+    """
+    Removes the provided tags from the command stored under the provided alias.
+    """
+    log.debug("var.tag.remove called. name=%s, tags=%s", name, tags)
+    variable_handlers.run_detach_tags(
+        name=name,
+        tag_names=tags,
+        get_var_services=container.get_variable_services,
+        get_tag_services=container.get_tag_services,
+        get_console=container.get_console,
+    )

cmdbox/cli/common/errors.py

@@ -0,0 +1,58 @@
+import logging
+from functools import wraps
+from typing import Callable
+
+import typer
+
+from cmdbox.cli.ui.console import ConsoleUI
+from cmdbox.exceptions import CmdboxError
+
+log = logging.getLogger(__name__)
+
+
+def make_cli_guard(
+    get_console: Callable[[], ConsoleUI],
+) -> Callable[[Callable], Callable]:
+    """
+    Creates a decorator to handle exceptions in CLI commands and provide uniform error
+    handling and messaging via a ConsoleUI instance.
+
+    The decorator wraps any given function, intercepting exceptions raised during its execution.
+    If an unexpected exception occurs, it is logged using the ConsoleUI's error handler,
+    and the program exits with a specific error code.
+
+    Args:
+        get_console: Callable that returns a `ConsoleUI` instance. Used to handle error
+            messages and output them in a consistent manner during CLI execution.
+
+    Returns:
+        Callable: A decorator function that processes the given function, wrapping it with
+        exception handling and error reporting logic.
+    """
+
+    def cli_guard(fn):
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            try:
+                return fn(*args, **kwargs)
+            except typer.BadParameter:
+                log.error("Invalid parameter(s) provided.")
+                raise
+            except typer.Exit:
+                log.debug("Exiting CLI. Typer exit raised.")
+                raise
+            except CmdboxError as exc:
+                log.error(exc)
+                console = get_console()
+                console.error(str(exc))
+                raise typer.Exit(code=1)
+            except Exception as exc:
+                message = f"An unexpected error occurred: {exc}"
+                log.critical(message, exc_info=True)
+                console = get_console()
+                console.error(message)
+                raise typer.Exit(code=1)
+
+        return wrapper
+
+    return cli_guard