EIC code displayed by LXR master/​AID2E-framework/​src/​aid2e/​cli/​workflow_commands.py	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-12 08:24:55

 """
 Workflow execution commands for AID2E CLI.
 
 Commands for running optimization workflows and managing execution lifecycle:
 - optimize: Run optimization from configuration (current placeholder)
 - run: Execute full workflow (planned)
 - resume: Restart from checkpoint (planned)
 - stop: Halt running optimization (planned)
 - status: Check optimization progress (planned)
 - clean: Remove temporary files (planned)
 """
 
 import sys
 from typing import Optional
 
 import click
 
 from aid2e.utilities.configurations import load_config
 
 from aid2e.utilities.workflows.toy_evaluator import run_epic_b0_toy_optimization
 
 @click.command(name="optimize")
 @click.argument("config_file", type=click.Path(exists=True))
 @click.option("--validate-only", is_flag=True, help="Validate config but do not run")
 @click.option("-v", "--verbosity", count=True, help="Increase verbosity (can be used multiple times)")
 @click.option("--log", "log_file", type=click.Path(dir_okay=False), help="Path to log file")
 def optimize(config_file: str, validate_only: bool, verbosity: int, log_file: Optional[str]):
     """
     Run optimization based on configuration file.
     
     CONFIG_FILE: Path to the YAML configuration file.
     
     Example:
         aid2e optimize optimization.yml
         aid2e optimize optimization.yml --validate-only
         aid2e optimize optimization.yml -vv --log output.log
     """
     try:
         if verbosity > 0:
             click.echo(f"Loading configuration from: {config_file}")
         
         config = load_config(config_file)
         
         if validate_only:
             click.echo(click.style("✓ Configuration validated; skipping execution.", fg="green"))
             return
         
         # Display optimization info
         click.echo(click.style(f"Running optimization: {config.optimizer.name}", fg="cyan", bold=True))
         click.echo(f"  Algorithm: {config.optimizer.name} ({config.optimizer.type})")
         click.echo(f"  Iterations: {config.optimizer.parameters.get('n_iterations', 'N/A')}")
         click.echo(f"  Verbosity: {verbosity}")
         if log_file:
             click.echo(f"  Log file: {log_file}")
         click.echo()
         
         # TODO: Implement actual optimization execution
         # This will involve:
         # 1. Instantiate optimizer from config.optimizer
         # 2. Setup problem evaluator from config.problem
         # 3. Run optimization loop
         # 4. Save results to config.problem.output_location
         
         # click.echo(click.style("Note: Optimizer execution not yet implemented.", fg="yellow"))
         # click.echo("The configuration has been validated and is ready for optimization.")
 
         # === Addressed TODO for B0 (toy model placeholder as objective function, to be replaced by Geant4 simulations later)
         if config.problem.problem_type == "EPIC_B0":
             run_epic_b0_toy_optimization(config, verbosity)
             return
 
     except Exception as e:
         click.echo(click.style(f"✗ Error: {e}", fg="red"), err=True)
         if verbosity > 1:
             import traceback
             traceback.print_exc()
         sys.exit(1)
 
 
 # Future commands (placeholders for documentation)
 
 def run_command():
     """
     Execute complete optimization workflow (PLANNED).
     
     Will support:
     - Full orchestration: config → problem → optimizer → execution → results
     - Checkpoint/resume support
     - Output directory override
     - Dry-run mode
     
     Usage:
         aid2e run config.yml
         aid2e run config.yml --dry-run
         aid2e run config.yml --output results/experiment_1/
         aid2e run config.yml --resume checkpoint.json
     """
     pass
 
 
 def resume_command():
     """
     Resume optimization from checkpoint (PLANNED).
     
     Will support:
     - Restart interrupted optimization from saved state
     - Continue from specific iteration
     - Merge results with previous runs
     
     Usage:
         aid2e resume checkpoint.json
         aid2e resume checkpoint.json --iterations 50
     """
     pass
 
 
 def stop_command():
     """
     Gracefully halt running optimization (PLANNED).
     
     Will support:
     - Stop by run ID or process ID
     - Save checkpoint before stopping
     - Force stop option
     
     Usage:
         aid2e stop <run_id>
         aid2e stop <run_id> --force
         aid2e stop --all
     """
     pass
 
 
 def status_command():
     """
     Check progress of optimizations (PLANNED).
     
     Will support:
     - Show active runs
     - Display iteration progress
     - Show current best objectives
     - List completed runs
     
     Usage:
         aid2e status
         aid2e status <run_id>
         aid2e status --all
     """
     pass
 
 
 def clean_command():
     """
     Remove temporary and intermediate files (PLANNED).
     
     Will support:
     - Clean work directories
     - Remove old checkpoints
     - Clear cache files
     - Dry-run to preview deletions
     
     Usage:
         aid2e clean <output_dir>
         aid2e clean <output_dir> --dry-run
         aid2e clean <output_dir> --keep-checkpoints
     """
     pass

This page was automatically generated by the 2.3.7 LXR engine. The LXR team