Placeholders are being prompted, but later still excepts.

Author: GeigerJ2

src/aiida/cmdline/commands/cmd_computer.py

@@ -285,6 +285,7 @@ def set_template_vars_in_context(ctx, param, value):
     return value
 
 
+
 # Modified computer setup command
 @verdi_computer.command('setup')
 @options_computer.LABEL()
@@ -300,17 +301,19 @@ def set_template_vars_in_context(ctx, param, value):
 @options_computer.USE_DOUBLE_QUOTES()
 @options_computer.PREPEND_TEXT()
 @options_computer.APPEND_TEXT()
-# @options.NON_INTERACTIVE()
-# @options.CONFIG_FILE()  # Keep the original config option for backward compatibility
-@options.TEMPLATE_FILE()  # Add our new template option
+@options.NON_INTERACTIVE()  # Uncomment this line
+@options.TEMPLATE_FILE()
 @options.TEMPLATE_VARS()
 @click.pass_context
 @with_dbenv()
 def computer_setup(ctx, non_interactive, template, template_vars, **kwargs):
     """Create a new computer."""
     from aiida.orm.utils.builders.computer import ComputerBuilder
 
-    print('HELLO')
+    # Debug output
+    print(f"Debug: non_interactive = {non_interactive}")
+    print(f"Debug: kwargs keys = {list(kwargs.keys())}")
+    print(f"Debug: ctx.default_map = {ctx.default_map}")
 
     # Handle template variables
     template_var_dict = None
@@ -369,6 +372,90 @@ def computer_setup(ctx, non_interactive, template, template_vars, **kwargs):
     profile = ctx.obj['profile']
     echo.echo_report(f'  verdi -p {profile.name} computer configure {computer.transport_type} {computer.label}')
 
+# Modified computer setup command
+# @verdi_computer.command('setup')
+# @options_computer.LABEL()
+# @options_computer.HOSTNAME()
+# @options_computer.DESCRIPTION()
+# @options_computer.TRANSPORT()
+# @options_computer.SCHEDULER()
+# @options_computer.SHEBANG()
+# @options_computer.WORKDIR()
+# @options_computer.MPI_RUN_COMMAND()
+# @options_computer.MPI_PROCS_PER_MACHINE()
+# @options_computer.DEFAULT_MEMORY_PER_MACHINE()
+# @options_computer.USE_DOUBLE_QUOTES()
+# @options_computer.PREPEND_TEXT()
+# @options_computer.APPEND_TEXT()
+# # @options.NON_INTERACTIVE()
+# # @options.CONFIG_FILE()  # Keep the original config option for backward compatibility
+# @options.TEMPLATE_FILE()  # Add our new template option
+# @options.TEMPLATE_VARS()
+# @click.pass_context
+# @with_dbenv()
+# def computer_setup(ctx, non_interactive, template, template_vars, **kwargs):
+#     """Create a new computer."""
+#     from aiida.orm.utils.builders.computer import ComputerBuilder
+
+#     print('HELLO')
+
+#     # Handle template variables
+#     template_var_dict = None
+#     if template_vars:
+#         try:
+#             template_var_dict = json.loads(template_vars)
+#         except json.JSONDecodeError as e:
+#             echo.echo_critical(f'Invalid JSON in template-vars: {e}')
+
+#     # Process template if provided
+#     if template:
+#         try:
+#             # Load and process the template
+#             config_data = load_and_process_template(
+#                 template, interactive=not non_interactive, template_vars=template_var_dict
+#             )
+
+#             # Update kwargs with config file data
+#             # Only update if the value wasn't explicitly provided on command line
+#             for key, value in config_data.items():
+#                 if key not in kwargs or kwargs[key] is None:
+#                     kwargs[key] = value
+
+#         except Exception as e:
+#             echo.echo_critical(f'Error processing template: {e}')
+
+#     # Check for existing computer
+#     if kwargs.get('label') and kwargs['label'] in get_computer_names():
+#         echo.echo_critical(
+#             'A computer called {c} already exists. '
+#             'Use "verdi computer duplicate {c}" to set up a new '
+#             'computer starting from the settings of {c}.'.format(c=kwargs['label'])
+#         )
+
+#     # Convert entry points to their names
+#     if kwargs.get('transport'):
+#         kwargs['transport'] = kwargs['transport'].name
+#     if kwargs.get('scheduler'):
+#         kwargs['scheduler'] = kwargs['scheduler'].name
+
+#     computer_builder = ComputerBuilder(**kwargs)
+#     try:
+#         computer = computer_builder.new()
+#     except (ComputerBuilder.ComputerValidationError, ValidationError) as e:
+#         echo.echo_critical(f'{type(e).__name__}: {e}')
+
+#     try:
+#         computer.store()
+#     except ValidationError as err:
+#         echo.echo_critical(f'unable to store the computer: {err}. Exiting...')
+#     else:
+#         echo.echo_success(f'Computer<{computer.pk}> {computer.label} created')
+
+#     echo.echo_report('Note: before the computer can be used, it has to be configured with the command:')
+
+#     profile = ctx.obj['profile']
+#     echo.echo_report(f'  verdi -p {profile.name} computer configure {computer.transport_type} {computer.label}')
+
 
 @verdi_computer.command('duplicate')
 @arguments.COMPUTER(callback=set_computer_builder)

src/aiida/cmdline/params/options/config.py

@@ -75,9 +75,6 @@ def configuration_callback(
         except Exception as exception:
             raise click.BadOptionUsage(option_name, f'Error reading configuration file: {exception}', ctx)
 
-        import ipdb
-
-        ipdb.set_trace()
         valid_params = [param.name for param in ctx.command.params if param.name != option_name]
         specified_params = list(config.keys())
         unknown_params = set(specified_params).difference(set(valid_params))

src/aiida/cmdline/params/options/main.py

@@ -913,18 +913,98 @@ def set_log_level(ctx, _param, value):
     help='End date for node mtime range selection for node collection dumping.',
 )
 
-# Add a new option for template variables in non-interactive mode
-TEMPLATE_VARS = OverridableOption(
-    '--template-vars',
-    type=click.STRING,
-    help='JSON string containing template variable values for non-interactive mode. '
-    'Example: \'{"label": "my-computer", "slurm_account": "my_account"}\'',
-)
+import click
+
+from aiida.cmdline.utils import echo
+from aiida.cmdline.utils.template_config import load_and_process_template
+
+from .overridable import OverridableOption
+
+
+class TemplateOption(OverridableOption):
+    """Option that processes Jinja2 templates and updates Click context defaults."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the template option."""
+        kwargs.setdefault('is_eager', True)  # Process template before other options
+        kwargs.setdefault('expose_value', False)  # Don't pass template to the command function
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, **kwargs):
+        """Create the option with updated kwargs."""
+        kw_copy = self.kwargs.copy()
+        kw_copy.update(kwargs)
+
+        # Set the callback to process the template
+        saved_callback = kw_copy.get('callback')
+        kw_copy['callback'] = lambda ctx, param, value: self._process_template(ctx, param, value, saved_callback)
+
+        return click.option(*self.args, **kw_copy)
+
+    def _process_template(self, ctx, param, value, saved_callback):
+        """Process the template file and update context defaults."""
+        if not value:
+            return saved_callback(ctx, param, value) if saved_callback else value
+
+        ctx.default_map = ctx.default_map or {}
 
-# Create an enhanced config file option
-TEMPLATE_FILE = OverridableOption(
+        # Get template vars from context if they were set by TEMPLATE_VARS option
+        template_vars = getattr(ctx, '_template_vars', None)
+
+        # Determine if we're in non-interactive mode
+        non_interactive = False
+        for ctx_param in ctx.params.values():
+            if isinstance(ctx_param, bool) and 'non_interactive' in str(ctx_param):
+                non_interactive = ctx_param
+                break
+
+        try:
+            # Load and process the template
+            config_data = load_and_process_template(value, interactive=not non_interactive, template_vars=template_vars)
+
+            # Update the default map with template values
+            # This will set defaults for options that haven't been explicitly provided
+            for key, template_value in config_data.items():
+                if key not in ctx.default_map:
+                    ctx.default_map[key] = template_value
+
+        except Exception as e:
+            echo.echo_critical(f'Error processing template: {e}')
+
+        return saved_callback(ctx, param, value) if saved_callback else value
+
+
+# Updated TEMPLATE_FILE option
+TEMPLATE_FILE = TemplateOption(
     '--template',
     type=click.STRING,
     help='Load computer setup from configuration file in YAML format (local path or URL). '
     'Supports Jinja2 templates with interactive prompting.',
 )
+
+import json
+
+
+# Helper function to set template vars in context (updated)
+def set_template_vars_in_context(ctx, param, value):
+    """Set template variables in the context for the template option to use."""
+    if value:
+        try:
+            template_var_dict = json.loads(value)
+            # Store template vars in context for the template option to use
+            ctx._template_vars = template_var_dict
+        except json.JSONDecodeError as e:
+            raise click.BadParameter(f'Invalid JSON in template-vars: {e}')
+    return value
+
+
+# Updated TEMPLATE_VARS option with callback
+TEMPLATE_VARS = OverridableOption(
+    '--template-vars',
+    type=click.STRING,
+    is_eager=True,  # Process before template option
+    callback=set_template_vars_in_context,
+    expose_value=False,  # Don't pass to command function
+    help='JSON string containing template variable values for non-interactive mode. '
+    'Example: \'{"label": "my-computer", "slurm_account": "my_account"}\'',
+)