Coverage for sparkle/CLI/run_configured_solver.py: 0%

1#!/usr/bin/env python3 

2"""Sparkle command to execute a configured solver.""" 

3 

4import sys 

5import argparse 

6from pathlib import PurePath 

7 

8from runrunner.base import Runner 

9 

10from sparkle.CLI.help import global_variables as gv 

11from sparkle.CLI.help import logging as sl 

12from sparkle.platform.settings_objects import Settings, SettingState 

13from sparkle.instance import instance_set 

14from sparkle.platform import CommandName, COMMAND_DEPENDENCIES 

15from sparkle.CLI.initialise import check_for_initialise 

16from sparkle.CLI.help import argparse_custom as ac 

17from sparkle.CLI.help.nicknames import resolve_object_name 

18 

19 

20def parser_function() -> argparse.ArgumentParser: 

21 """Define the command line arguments.""" 

22 parser = argparse.ArgumentParser() 

23 parser.add_argument(*ac.InstancePathPositional.names, 

24 **ac.InstancePathPositional.kwargs) 

25 parser.add_argument(*ac.SettingsFileArgument.names, 

26 **ac.SettingsFileArgument.kwargs) 

27 parser.add_argument(*ac.SparkleObjectiveArgument.names, 

28 **ac.SparkleObjectiveArgument.kwargs) 

29 parser.add_argument(*ac.RunOnArgument.names, 

30 **ac.RunOnArgument.kwargs) 

31 return parser 

32 

33 

34if __name__ == "__main__": 

35 # Log command call 

36 sl.log_command(sys.argv) 

37 

38 # Define command line arguments 

39 parser = parser_function() 

40 

41 # Process command line arguments 

42 args = parser.parse_args() 

43 

44 # Try to resolve the instance path (Dir or list instance paths) 

45 data_set = resolve_object_name( 

46 args.instance_path, 

47 gv.file_storage_data_mapping[gv.instances_nickname_path], 

48 gv.settings().DEFAULT_instance_dir, instance_set) 

49 if data_set is None: 

50 print(f"Could not resolve instance (set): {args.instance_path}! Exiting...") 

51 sys.exit(-1) 

52 

53 if args.run_on is not None: 

54 gv.settings().set_run_on( 

55 args.run_on.value, SettingState.CMD_LINE) 

56 run_on = gv.settings().get_run_on() 

57 

58 check_for_initialise(COMMAND_DEPENDENCIES[CommandName.RUN_CONFIGURED_SOLVER]) 

59 

60 if args.settings_file is not None: 

61 # Do first, so other command line options can override settings from the file 

62 gv.settings().read_settings_ini(args.settings_file, SettingState.CMD_LINE) 

63 if args.objectives is not None: 

64 gv.settings().set_general_sparkle_objectives( 

65 args.objectives, SettingState.CMD_LINE 

66 ) 

67 

68 # Compare current settings to latest.ini 

69 prev_settings = Settings(PurePath("Settings/latest.ini")) 

70 Settings.check_settings_changes(gv.settings(), prev_settings) 

71 

72 # Get the name of the configured solver and the training set 

73 solver = gv.latest_scenario().get_config_solver() 

74 train_set = gv.latest_scenario().get_config_instance_set_train() 

75 custom_cutoff = gv.settings().get_general_target_cutoff_time() 

76 if solver is None or train_set is None: 

77 # Print error and stop execution 

78 print("ERROR: No configured solver found! Stopping execution.") 

79 sys.exit(-1) 

80 # Get optimised configuration 

81 configurator = gv.settings().get_general_sparkle_configurator() 

82 objectives = gv.settings().get_general_sparkle_objectives() 

83 _, config_str = configurator.get_optimal_configuration( 

84 solver, train_set, objective=objectives[0]) 

85 config = solver.config_str_to_dict(config_str) 

86 # Call the configured solver 

87 sbatch_options = gv.settings().get_slurm_extra_options(as_args=True) 

88 if run_on == Runner.LOCAL: 

89 print(f"Start running solver on {data_set.size} instances...") 

90 run = solver.run(instance=data_set, 

91 objectives=objectives, 

92 seed=gv.get_seed(), 

93 cutoff_time=custom_cutoff, 

94 configuration=config, 

95 run_on=run_on, 

96 commandname=CommandName.RUN_CONFIGURED_SOLVER, 

97 sbatch_options=sbatch_options, 

98 cwd=sl.caller_log_dir) 

99 

100 # Print result 

101 if run_on == Runner.SLURM: 

102 print(f"Running configured solver. Waiting for Slurm " 

103 f"job(s) with id(s): {run.run_id}") 

104 else: 

105 if isinstance(run, dict): 

106 run = [run] 

107 for i, solver_output in enumerate(run): 

108 print(f"Execution of {solver.name} on instance " 

109 f"{data_set.instance_names[i]} completed with status " 

110 f"{solver_output['status']} in {solver_output['cpu_time']} seconds.") 

111 print("Running configured solver done!") 

112 

113 # Write used settings to file 

114 gv.settings().write_used_settings()