Coverage for sparkle/platform/settings_objects.py: 90%

1"""Classes and Enums to control settings.""" 

2from __future__ import annotations 

3import configparser 

4from enum import Enum 

5import ast 

6from pathlib import Path 

7from pathlib import PurePath 

8 

9from sparkle.types import SparkleObjective, resolve_objective 

10from sparkle.types.objective import PAR 

11from sparkle.solver import Selector 

12from sparkle.configurator.configurator import Configurator 

13from sparkle.solver.verifier import SATVerifier 

14from sparkle.configurator import implementations as cim 

15 

16from runrunner import Runner 

17from sparkle.platform.cli_types import VerbosityLevel 

18 

19 

20class SettingState(Enum): 

21 """Enum of possible setting states.""" 

22 

23 NOT_SET = 0 

24 DEFAULT = 1 

25 FILE = 2 

26 CMD_LINE = 3 

27 

28 

29class Settings: 

30 """Class to read, write, set, and get settings.""" 

31 # CWD Prefix 

32 cwd_prefix = Path() # Empty for now 

33 

34 # Library prefix 

35 lib_prefix = Path(__file__).parent.parent.resolve() 

36 

37 # Default directory names 

38 rawdata_dir = Path("Raw_Data") 

39 analysis_dir = Path("Analysis") 

40 DEFAULT_settings_dir = Path("Settings") 

41 __settings_file = Path("sparkle_settings.ini") 

42 

43 # Default settings path 

44 DEFAULT_settings_path = PurePath(cwd_prefix / DEFAULT_settings_dir / __settings_file) 

45 

46 # Default library pathing 

47 DEFAULT_components = lib_prefix / "Components" 

48 

49 # Example settings path 

50 DEFAULT_example_settings_path = PurePath(DEFAULT_components / "sparkle_settings.ini") 

51 

52 # Runsolver component 

53 DEFAULT_runsolver_dir = DEFAULT_components / "runsolver" / "src" 

54 DEFAULT_runsolver_exec = DEFAULT_runsolver_dir / "runsolver" 

55 

56 # Ablation component 

57 DEFAULT_ablation_dir = DEFAULT_components / "ablationAnalysis-0.9.4" 

58 DEFAULT_ablation_exec = DEFAULT_ablation_dir / "ablationAnalysis" 

59 DEFAULT_ablation_validation_exec = DEFAULT_ablation_dir / "ablationValidation" 

60 

61 # Autofolio component 

62 DEFAULT_general_sparkle_selector = DEFAULT_components / "AutoFolio/scripts/autofolio" 

63 

64 # Report component 

65 DEFAULT_latex_source = DEFAULT_components / "Sparkle-latex-source" 

66 DEFAULT_latex_bib = DEFAULT_latex_source / "SparkleReport.bib" 

67 

68 # Default input directory pathing 

69 DEFAULT_solver_dir = cwd_prefix / "Solvers" 

70 DEFAULT_instance_dir = cwd_prefix / "Instances" 

71 DEFAULT_extractor_dir = cwd_prefix / "Extractors" 

72 DEFAULT_snapshot_dir = cwd_prefix / "Snapshots" 

73 

74 # Default output directory pathing 

75 DEFAULT_tmp_output = cwd_prefix / "Tmp" 

76 DEFAULT_output = cwd_prefix / "Output" 

77 DEFAULT_configuration_output = DEFAULT_output / "Configuration" 

78 DEFAULT_selection_output = DEFAULT_output / "Selection" 

79 DEFAULT_validation_output = DEFAULT_output / "Validation" 

80 DEFAULT_parallel_portfolio_output = DEFAULT_output / "Parallel_Portfolio" 

81 DEFAULT_ablation_output = DEFAULT_output / "Ablation" 

82 DEFAULT_log_output = DEFAULT_output / "Log" 

83 

84 # Default output subdirs 

85 DEFAULT_configuration_output_raw = DEFAULT_configuration_output / rawdata_dir 

86 DEFAULT_configuration_output_analysis = DEFAULT_configuration_output / analysis_dir 

87 DEFAULT_selection_output_raw = DEFAULT_selection_output / rawdata_dir 

88 DEFAULT_selection_output_analysis = DEFAULT_selection_output / analysis_dir 

89 DEFAULT_parallel_portfolio_output_raw =\ 

90 DEFAULT_parallel_portfolio_output / rawdata_dir 

91 DEFAULT_parallel_portfolio_output_analysis =\ 

92 DEFAULT_parallel_portfolio_output / analysis_dir 

93 

94 # Old default output dirs which should be part of something else 

95 DEFAULT_feature_data = DEFAULT_output / "Feature_Data" 

96 DEFAULT_performance_data = DEFAULT_output / "Performance_Data" 

97 

98 # Collection of all working dirs for platform 

99 DEFAULT_working_dirs = [ 

100 DEFAULT_output, DEFAULT_configuration_output, 

101 DEFAULT_selection_output, DEFAULT_validation_output, 

102 DEFAULT_tmp_output, DEFAULT_log_output, 

103 DEFAULT_solver_dir, DEFAULT_instance_dir, 

104 DEFAULT_feature_data, DEFAULT_performance_data, 

105 DEFAULT_extractor_dir, DEFAULT_settings_dir 

106 ] 

107 

108 # Old default file paths from GV which should be turned into variables 

109 DEFAULT_feature_data_path =\ 

110 DEFAULT_feature_data / "feature_data.csv" 

111 DEFAULT_performance_data_path =\ 

112 DEFAULT_performance_data / "performance_data.csv" 

113 

114 # Constant default values 

115 DEFAULT_general_sparkle_objective = PAR(10) 

116 DEFAULT_general_sparkle_configurator = cim.SMAC2.__name__ 

117 DEFAULT_general_solution_verifier = str(None) 

118 DEFAULT_general_target_cutoff_time = 60 

119 DEFAULT_general_extractor_cutoff_time = 60 

120 DEFAULT_number_of_jobs_in_parallel = 25 

121 DEFAULT_general_verbosity = VerbosityLevel.STANDARD 

122 DEFAULT_general_check_interval = 10 

123 DEFAULT_general_run_on = "local" 

124 

125 DEFAULT_configurator_number_of_runs = 25 

126 DEFAULT_configurator_solver_calls = 100 

127 DEFAULT_configurator_maximum_iterations = None 

128 

129 DEFAULT_smac2_wallclock_time = None 

130 DEFAULT_smac2_cpu_time = None 

131 DEFAULT_smac2_target_cutoff_length = "max" 

132 DEFAULT_smac2_use_cpu_time_in_tunertime = None 

133 DEFAULT_smac2_max_iterations = None 

134 

135 DEFAULT_portfolio_construction_timeout = None 

136 

137 DEFAULT_slurm_max_parallel_runs_per_node = 8 

138 

139 DEFAULT_ablation_racing = False 

140 

141 DEFAULT_parallel_portfolio_check_interval = 4 

142 DEFAULT_parallel_portfolio_num_seeds_per_solver = 1 

143 

144 # Default IRACE settings 

145 DEFAULT_irace_max_time = 0 # IRACE equivalent of None in this case 

146 DEFAULT_irace_max_experiments = 0 

147 DEFAULT_irace_first_test = None 

148 DEFAULT_irace_mu = None 

149 DEFAULT_irace_max_iterations = None 

150 

151 def __init__(self: Settings, file_path: PurePath = None) -> None: 

152 """Initialise a settings object.""" 

153 # Settings 'dictionary' in configparser format 

154 self.__settings = configparser.ConfigParser() 

155 

156 # Setting flags 

157 self.__general_sparkle_objective_set = SettingState.NOT_SET 

158 self.__general_sparkle_configurator_set = SettingState.NOT_SET 

159 self.__general_sparkle_selector_set = SettingState.NOT_SET 

160 self.__general_solution_verifier_set = SettingState.NOT_SET 

161 self.__general_target_cutoff_time_set = SettingState.NOT_SET 

162 self.__general_extractor_cutoff_time_set = SettingState.NOT_SET 

163 self.__general_verbosity_set = SettingState.NOT_SET 

164 self.__general_check_interval_set = SettingState.NOT_SET 

165 

166 self.__config_solver_calls_set = SettingState.NOT_SET 

167 self.__config_number_of_runs_set = SettingState.NOT_SET 

168 self.__config_max_iterations_set = SettingState.NOT_SET 

169 

170 self.__smac2_wallclock_time_set = SettingState.NOT_SET 

171 self.__smac2_cpu_time_set = SettingState.NOT_SET 

172 self.__smac2_use_cpu_time_in_tunertime_set = SettingState.NOT_SET 

173 self.__smac2_max_iterations_set = SettingState.NOT_SET 

174 

175 self.__run_on_set = SettingState.NOT_SET 

176 self.__number_of_jobs_in_parallel_set = SettingState.NOT_SET 

177 self.__slurm_max_parallel_runs_per_node_set = SettingState.NOT_SET 

178 self.__smac2_target_cutoff_length_set = SettingState.NOT_SET 

179 self.__ablation_racing_flag_set = SettingState.NOT_SET 

180 

181 self.__parallel_portfolio_check_interval_set = SettingState.NOT_SET 

182 self.__parallel_portfolio_num_seeds_per_solver_set = SettingState.NOT_SET 

183 

184 self.__irace_max_time_set = SettingState.NOT_SET 

185 self.__irace_max_experiments_set = SettingState.NOT_SET 

186 self.__irace_first_test_set = SettingState.NOT_SET 

187 self.__irace_mu_set = SettingState.NOT_SET 

188 self.__irace_max_iterations_set = SettingState.NOT_SET 

189 

190 self.__general_sparkle_configurator = None 

191 

192 self.__slurm_extra_options_set = dict() 

193 

194 if file_path is None: 

195 # Initialise settings from default file path 

196 self.read_settings_ini() 

197 else: 

198 # Initialise settings from a given file path 

199 self.read_settings_ini(file_path) 

200 

201 def read_settings_ini(self: Settings, file_path: PurePath = DEFAULT_settings_path, 

202 state: SettingState = SettingState.FILE) -> None: 

203 """Read the settings from an INI file.""" 

204 # Read file 

205 file_settings = configparser.ConfigParser() 

206 file_settings.read(file_path) 

207 

208 # Set internal settings based on data read from FILE if they were read 

209 # successfully 

210 if file_settings.sections() != []: 

211 section = "general" 

212 option_names = ("objective", ) 

213 for option in option_names: 

214 if file_settings.has_option(section, option): 

215 value = [resolve_objective(obj) for obj in 

216 file_settings.get(section, option).split(",")] 

217 self.set_general_sparkle_objectives(value, state) 

218 file_settings.remove_option(section, option) 

219 

220 # Comma so python understands it's a tuple... 

221 option_names = ("configurator", ) 

222 for option in option_names: 

223 if file_settings.has_option(section, option): 

224 value = file_settings.get(section, option) 

225 self.set_general_sparkle_configurator(value, state) 

226 file_settings.remove_option(section, option) 

227 

228 option_names = ("selector", ) 

229 for option in option_names: 

230 if file_settings.has_option(section, option): 

231 value = file_settings.get(section, option) 

232 self.set_general_sparkle_selector(value, state) 

233 file_settings.remove_option(section, option) 

234 

235 option_names = ("solution_verifier", ) 

236 for option in option_names: 

237 if file_settings.has_option(section, option): 

238 value = file_settings.get(section, option).lower() 

239 self.set_general_solution_verifier(value, state) 

240 file_settings.remove_option(section, option) 

241 

242 option_names = ("target_cutoff_time", 

243 "cutoff_time_each_solver_call") 

244 for option in option_names: 

245 if file_settings.has_option(section, option): 

246 value = file_settings.getint(section, option) 

247 self.set_general_target_cutoff_time(value, state) 

248 file_settings.remove_option(section, option) 

249 

250 option_names = ("extractor_cutoff_time", 

251 "cutoff_time_each_feature_computation") 

252 for option in option_names: 

253 if file_settings.has_option(section, option): 

254 value = file_settings.getint(section, option) 

255 self.set_general_extractor_cutoff_time(value, state) 

256 file_settings.remove_option(section, option) 

257 

258 option_names = ("run_on", ) 

259 for option in option_names: 

260 if file_settings.has_option(section, option): 

261 value = file_settings.get(section, option) 

262 self.set_run_on(value, state) 

263 file_settings.remove_option(section, option) 

264 

265 option_names = ("verbosity", ) 

266 for option in option_names: 

267 if file_settings.has_option(section, option): 

268 value = VerbosityLevel.from_string( 

269 file_settings.get(section, option)) 

270 self.set_general_verbosity(value, state) 

271 file_settings.remove_option(section, option) 

272 

273 option_names = ("check_interval", ) 

274 for option in option_names: 

275 if file_settings.has_option(section, option): 

276 value = int(file_settings.get(section, option)) 

277 self.set_general_check_interval(value, state) 

278 file_settings.remove_option(section, option) 

279 

280 section = "configuration" 

281 option_names = ("solver_calls", ) 

282 for option in option_names: 

283 if file_settings.has_option(section, option): 

284 value = file_settings.getint(section, option) 

285 self.set_configurator_solver_calls(value, state) 

286 file_settings.remove_option(section, option) 

287 

288 option_names = ("number_of_runs", ) 

289 for option in option_names: 

290 if file_settings.has_option(section, option): 

291 value = file_settings.getint(section, option) 

292 self.set_configurator_number_of_runs(value, state) 

293 file_settings.remove_option(section, option) 

294 

295 option_name = "max_iterations" 

296 if file_settings.has_option(section, option_name): 

297 value = file_settings.getint(section, option_name) 

298 self.set_configurator_max_iterations(value, state) 

299 file_settings.remove_option(section, option_name) 

300 

301 section = "smac2" 

302 option_names = ("wallclock_time", ) 

303 for option in option_names: 

304 if file_settings.has_option(section, option): 

305 value = file_settings.getint(section, option) 

306 self.set_smac2_wallclock_time(value, state) 

307 file_settings.remove_option(section, option) 

308 

309 option_names = ("cpu_time", ) 

310 for option in option_names: 

311 if file_settings.has_option(section, option): 

312 value = file_settings.getint(section, option) 

313 self.set_smac2_cpu_time(value, state) 

314 file_settings.remove_option(section, option) 

315 

316 option_names = ("target_cutoff_length", "each_run_cutoff_length") 

317 for option in option_names: 

318 if file_settings.has_option(section, option): 

319 value = file_settings.get(section, option) 

320 self.set_smac2_target_cutoff_length(value, state) 

321 file_settings.remove_option(section, option) 

322 

323 option_names = ("use_cpu_time_in_tunertime", "countSMACTimeAsTunerTime") 

324 for option in option_names: 

325 if file_settings.has_option(section, option): 

326 value = file_settings.getboolean(section, option) 

327 self.set_smac2_use_cpu_time_in_tunertime(value, state) 

328 file_settings.remove_option(section, option) 

329 

330 options_names = ("iteration_limit", "numIterations", "numberOfIterations", 

331 "max_iterations") 

332 for option in options_names: 

333 if file_settings.has_option(section, option): 

334 value = file_settings.getint(section, option) 

335 self.set_smac2_max_iterations(value, state) 

336 file_settings.remove_option(section, option) 

337 

338 section = "irace" 

339 option_names = ("max_time", ) 

340 for option in option_names: 

341 if file_settings.has_option(section, option): 

342 value = file_settings.getint(section, option) 

343 self.set_irace_max_time(value, state) 

344 file_settings.remove_option(section, option) 

345 

346 option_names = ("max_experiments", ) 

347 for option in option_names: 

348 if file_settings.has_option(section, option): 

349 value = file_settings.getint(section, option) 

350 self.set_irace_max_experiments(value, state) 

351 file_settings.remove_option(section, option) 

352 

353 option_names = ("first_test", ) 

354 for option in option_names: 

355 if file_settings.has_option(section, option): 

356 value = file_settings.getint(section, option) 

357 self.set_irace_first_test(value, state) 

358 file_settings.remove_option(section, option) 

359 

360 option_names = ("mu", ) 

361 for option in option_names: 

362 if file_settings.has_option(section, option): 

363 value = file_settings.getint(section, option) 

364 self.set_irace_mu(value, state) 

365 file_settings.remove_option(section, option) 

366 

367 option_names = ("nb_iterations", "iterations", "max_iterations") 

368 for option in option_names: 

369 if file_settings.has_option(section, option): 

370 value = file_settings.getint(section, option) 

371 self.set_irace_max_iterations(value, state) 

372 file_settings.remove_option(section, option) 

373 

374 section = "slurm" 

375 option_names = ("number_of_jobs_in_parallel", "num_job_in_parallel") 

376 for option in option_names: 

377 if file_settings.has_option(section, option): 

378 value = file_settings.getint(section, option) 

379 self.set_number_of_jobs_in_parallel(value, state) 

380 file_settings.remove_option(section, option) 

381 

382 option_names = ("max_parallel_runs_per_node", "clis_per_node") 

383 for option in option_names: 

384 if file_settings.has_option(section, option): 

385 value = file_settings.getint(section, option) 

386 self.set_slurm_max_parallel_runs_per_node(value, state) 

387 file_settings.remove_option(section, option) 

388 

389 section = "ablation" 

390 option_names = ("racing", "ablation_racing") 

391 for option in option_names: 

392 if file_settings.has_option(section, option): 

393 value = file_settings.getboolean(section, option) 

394 self.set_ablation_racing_flag(value, state) 

395 file_settings.remove_option(section, option) 

396 

397 section = "parallel_portfolio" 

398 option_names = ("check_interval", ) 

399 for option in option_names: 

400 if file_settings.has_option(section, option): 

401 value = int(file_settings.get(section, option)) 

402 self.set_parallel_portfolio_check_interval(value, state) 

403 file_settings.remove_option(section, option) 

404 

405 option_names = ("num_seeds_per_solver", ) 

406 for option in option_names: 

407 if file_settings.has_option(section, option): 

408 value = int(file_settings.get(section, option)) 

409 self.set_parallel_portfolio_number_of_seeds_per_solver(value, state) 

410 file_settings.remove_option(section, option) 

411 

412 # TODO: Report on any unknown settings that were read 

413 sections = file_settings.sections() 

414 

415 for section in sections: 

416 for option in file_settings[section]: 

417 # TODO: Should check the options are valid Slurm options 

418 if section == "slurm": 

419 value = file_settings.get(section, option) 

420 self.add_slurm_extra_option(option, value, state) 

421 else: 

422 print(f'Unrecognised section - option combination: "{section} ' 

423 f'{option}" in file {file_path} ignored') 

424 

425 # Print error if unable to read the settings 

426 else: 

427 print(f"ERROR: Failed to read settings from {file_path} The file may have " 

428 "been empty, located in a different path, or be in another format than" 

429 " INI. Default Settings values be used.") 

430 

431 def write_used_settings(self: Settings) -> None: 

432 """Write the used settings to the default locations.""" 

433 # Write to latest settings file 

434 self.write_settings_ini(self.DEFAULT_settings_dir / "latest.ini") 

435 

436 def write_settings_ini(self: Settings, file_path: Path) -> None: 

437 """Write the settings to an INI file.""" 

438 # Create needed directories if they don't exist 

439 file_path.parent.mkdir(parents=True, exist_ok=True) 

440 slurm_extra_section_options = None 

441 if self.__settings.has_section("slurm_extra"): 

442 # Slurm extra options are not written as a seperate section 

443 slurm_extra_section_options = {} 

444 for key in self.__settings["slurm_extra"]: 

445 self.__settings["slurm"][key] = self.__settings["slurm_extra"][key] 

446 slurm_extra_section_options[key] = self.__settings["slurm_extra"][key] 

447 self.__settings.remove_section("slurm_extra") 

448 # We do not write None values 

449 removed = [] 

450 for section in self.__settings.sections(): 

451 for option in self.__settings[section]: 

452 try: 

453 if ast.literal_eval(str(self.__settings[section][option])) is None: 

454 del self.__settings[section][option] 

455 removed.append((section, option)) 

456 except Exception: 

457 pass 

458 # Write the settings to file 

459 with file_path.open("w") as settings_file: 

460 self.__settings.write(settings_file) 

461 # Rebuild slurm extra if needed 

462 if slurm_extra_section_options is not None: 

463 self.__settings.add_section("slurm_extra") 

464 for key in slurm_extra_section_options: 

465 self.__settings["slurm_extra"][key] = slurm_extra_section_options[key] 

466 # Rebuild None if needed 

467 for section, option in removed: 

468 self.__settings[section][option] = "None" 

469 

470 def __init_section(self: Settings, section: str) -> None: 

471 if section not in self.__settings: 

472 self.__settings[section] = {} 

473 

474 @staticmethod 

475 def __check_setting_state(current_state: SettingState, 

476 new_state: SettingState, name: str) -> bool: 

477 change_setting_ok = True 

478 

479 if current_state == SettingState.FILE and new_state == SettingState.DEFAULT: 

480 change_setting_ok = False 

481 print(f"Warning: Attempting to overwrite setting for {name} with default " 

482 "value; keeping the value read from file!") 

483 elif (current_state == SettingState.CMD_LINE 

484 and new_state == SettingState.DEFAULT): 

485 change_setting_ok = False 

486 print(f"Warning: Attempting to overwrite setting for {name} with default " 

487 "value; keeping the value read from command line!") 

488 elif current_state == SettingState.CMD_LINE and new_state == SettingState.FILE: 

489 change_setting_ok = False 

490 print(f"Warning: Attempting to overwrite setting for {name} with value from " 

491 "file; keeping the value read from command line!") 

492 

493 return change_setting_ok 

494 

495 # General settings ### 

496 def set_general_sparkle_objectives( 

497 self: Settings, 

498 value: list[SparkleObjective] = [DEFAULT_general_sparkle_objective, ], 

499 origin: SettingState = SettingState.DEFAULT) -> None: 

500 """Set the sparkle objective.""" 

501 section = "general" 

502 name = "objective" 

503 if value is not None and self.__check_setting_state( 

504 self.__general_sparkle_objective_set, origin, name): 

505 if isinstance(value, list): 

506 value = ",".join([str(obj) for obj in value]) 

507 else: 

508 value = str(value) 

509 # Append standard Sparkle Objectives 

510 if "status" not in value: 

511 value += ",status" 

512 if "cpu_time" not in value: 

513 value += ",cpu_time" 

514 if "wall_time" not in value: 

515 value += ",wall_time" 

516 if "memory" not in value: 

517 value += ",memory" 

518 self.__init_section(section) 

519 self.__general_sparkle_objective_set = origin 

520 self.__settings[section][name] = value 

521 

522 def get_general_sparkle_objectives(self: Settings) -> list[SparkleObjective]: 

523 """Return the performance measure.""" 

524 if self.__general_sparkle_objective_set == SettingState.NOT_SET: 

525 self.set_general_sparkle_objectives() 

526 

527 return [resolve_objective(obj) 

528 for obj in self.__settings["general"]["objective"].split(",")] 

529 

530 def set_general_sparkle_configurator( 

531 self: Settings, 

532 value: str = DEFAULT_general_sparkle_configurator, 

533 origin: SettingState = SettingState.DEFAULT) -> None: 

534 """Set the Sparkle configurator.""" 

535 section = "general" 

536 name = "configurator" 

537 if value is not None and self.__check_setting_state( 

538 self.__general_sparkle_configurator_set, origin, name): 

539 self.__init_section(section) 

540 self.__general_sparkle_configurator_set = origin 

541 self.__settings[section][name] = value 

542 

543 def get_general_sparkle_configurator(self: Settings) -> Configurator: 

544 """Return the configurator init method.""" 

545 if self.__general_sparkle_configurator_set == SettingState.NOT_SET: 

546 self.set_general_sparkle_configurator() 

547 configurator_var = self.__settings["general"]["configurator"] 

548 if (self.__general_sparkle_configurator is None 

549 or self.__general_sparkle_configurator.name != configurator_var): 

550 configurator_subclass =\ 

551 cim.resolve_configurator(self.__settings["general"]["configurator"]) 

552 if configurator_subclass is not None: 

553 self.__general_sparkle_configurator = configurator_subclass( 

554 base_dir=Path(), 

555 output_path=Settings.DEFAULT_configuration_output_raw) 

556 else: 

557 print("WARNING: Configurator class name not recognised: " 

558 f'{self.__settings["general"]["configurator"]}. ' 

559 "Configurator not set.") 

560 return self.__general_sparkle_configurator 

561 

562 def set_general_sparkle_selector( 

563 self: Settings, 

564 value: Path = DEFAULT_general_sparkle_selector, 

565 origin: SettingState = SettingState.DEFAULT) -> None: 

566 """Set the Sparkle selector.""" 

567 section = "general" 

568 name = "selector" 

569 if value is not None and self.__check_setting_state( 

570 self.__general_sparkle_selector_set, origin, name): 

571 self.__init_section(section) 

572 self.__general_sparkle_selector_set = origin 

573 self.__settings[section][name] = str(value) 

574 

575 def get_general_sparkle_selector(self: Settings) -> Selector: 

576 """Return the selector init method.""" 

577 if self.__general_sparkle_selector_set == SettingState.NOT_SET: 

578 self.set_general_sparkle_selector() 

579 return Selector(Path(self.__settings["general"]["selector"]), 

580 self.DEFAULT_selection_output_raw) 

581 

582 def set_general_solution_verifier( 

583 self: Settings, value: str = DEFAULT_general_solution_verifier, 

584 origin: SettingState = SettingState.DEFAULT) -> None: 

585 """Set the solution verifier to use.""" 

586 section = "general" 

587 name = "solution_verifier" 

588 

589 if value is not None and self.__check_setting_state( 

590 self.__general_solution_verifier_set, origin, name): 

591 self.__init_section(section) 

592 self.__general_solution_verifier_set = origin 

593 self.__settings[section][name] = value 

594 

595 def get_general_solution_verifier(self: Settings) -> object: 

596 """Return the solution verifier to use.""" 

597 if self.__general_solution_verifier_set == SettingState.NOT_SET: 

598 self.set_general_solution_verifier() 

599 name = self.__settings["general"]["solution_verifier"].lower() 

600 if name == str(SATVerifier()).lower(): 

601 return SATVerifier() 

602 return None 

603 

604 def set_general_target_cutoff_time( 

605 self: Settings, value: int = DEFAULT_general_target_cutoff_time, 

606 origin: SettingState = SettingState.DEFAULT) -> None: 

607 """Set the cutoff time in seconds for target algorithms.""" 

608 section = "general" 

609 name = "target_cutoff_time" 

610 

611 if value is not None and self.__check_setting_state( 

612 self.__general_target_cutoff_time_set, origin, name): 

613 self.__init_section(section) 

614 self.__general_target_cutoff_time_set = origin 

615 self.__settings[section][name] = str(value) 

616 

617 def get_general_target_cutoff_time(self: Settings) -> int: 

618 """Return the cutoff time in seconds for target algorithms.""" 

619 if self.__general_target_cutoff_time_set == SettingState.NOT_SET: 

620 self.set_general_target_cutoff_time() 

621 return int(self.__settings["general"]["target_cutoff_time"]) 

622 

623 def set_general_extractor_cutoff_time( 

624 self: Settings, value: int = DEFAULT_general_extractor_cutoff_time, 

625 origin: SettingState = SettingState.DEFAULT) -> None: 

626 """Set the cutoff time in seconds for feature extraction.""" 

627 section = "general" 

628 name = "extractor_cutoff_time" 

629 

630 if value is not None and self.__check_setting_state( 

631 self.__general_extractor_cutoff_time_set, origin, name): 

632 self.__init_section(section) 

633 self.__general_extractor_cutoff_time_set = origin 

634 self.__settings[section][name] = str(value) 

635 

636 def get_general_extractor_cutoff_time(self: Settings) -> int: 

637 """Return the cutoff time in seconds for feature extraction.""" 

638 if self.__general_extractor_cutoff_time_set == SettingState.NOT_SET: 

639 self.set_general_extractor_cutoff_time() 

640 return int(self.__settings["general"]["extractor_cutoff_time"]) 

641 

642 def set_number_of_jobs_in_parallel( 

643 self: Settings, value: int = DEFAULT_number_of_jobs_in_parallel, 

644 origin: SettingState = SettingState.DEFAULT) -> None: 

645 """Set the number of runs Sparkle can do in parallel.""" 

646 section = "slurm" 

647 name = "number_of_jobs_in_parallel" 

648 

649 if value is not None and self.__check_setting_state( 

650 self.__number_of_jobs_in_parallel_set, origin, name): 

651 self.__init_section(section) 

652 self.__number_of_jobs_in_parallel_set = origin 

653 self.__settings[section][name] = str(value) 

654 

655 def get_number_of_jobs_in_parallel(self: Settings) -> int: 

656 """Return the number of runs Sparkle can do in parallel.""" 

657 if self.__number_of_jobs_in_parallel_set == SettingState.NOT_SET: 

658 self.set_number_of_jobs_in_parallel() 

659 

660 return int(self.__settings["slurm"]["number_of_jobs_in_parallel"]) 

661 

662 def set_general_verbosity( 

663 self: Settings, value: VerbosityLevel = DEFAULT_general_verbosity, 

664 origin: SettingState = SettingState.DEFAULT) -> None: 

665 """Set the general verbosity to use.""" 

666 section = "general" 

667 name = "verbosity" 

668 

669 if value is not None and self.__check_setting_state( 

670 self.__general_verbosity_set, origin, name): 

671 self.__init_section(section) 

672 self.__general_verbosity_set = origin 

673 self.__settings[section][name] = value.name 

674 

675 def get_general_verbosity(self: Settings) -> VerbosityLevel: 

676 """Return the general verbosity.""" 

677 if self.__general_verbosity_set == SettingState.NOT_SET: 

678 self.set_general_verbosity() 

679 

680 return VerbosityLevel.from_string( 

681 self.__settings["general"]["verbosity"]) 

682 

683 def set_general_check_interval( 

684 self: Settings, 

685 value: int = DEFAULT_general_check_interval, 

686 origin: SettingState = SettingState.DEFAULT) -> None: 

687 """Set the general check interval.""" 

688 section = "general" 

689 name = "check_interval" 

690 

691 if value is not None and self.__check_setting_state( 

692 self.__general_check_interval_set, origin, name): 

693 self.__init_section(section) 

694 self.__general_check_interval_set = origin 

695 self.__settings[section][name] = str(value) 

696 

697 def get_general_check_interval(self: Settings) -> int: 

698 """Return the general check interval.""" 

699 if self.__general_check_interval_set == SettingState.NOT_SET: 

700 self.set_general_check_interval() 

701 

702 return int(self.__settings["general"]["check_interval"]) 

703 

704 # Configuration settings General ### 

705 

706 def get_configurator_settings(self: Settings, 

707 configurator_name: str) -> dict[str, any]: 

708 """Return the configurator settings.""" 

709 configurator_settings = { 

710 "number_of_runs": self.get_configurator_number_of_runs(), 

711 "solver_calls": self.get_configurator_solver_calls(), 

712 "cutoff_time": self.get_general_target_cutoff_time(), 

713 "max_iterations": self.get_configurator_max_iterations() 

714 } 

715 # In the settings below, we default to the configurator general settings if no 

716 # specific configurator settings are given, by using the [None] or [Value] 

717 if configurator_name == cim.SMAC2.__name__: 

718 # Return all settings from the SMAC2 section 

719 configurator_settings.update({ 

720 "cpu_time": self.get_smac2_cpu_time(), 

721 "wallclock_time": self.get_smac2_wallclock_time(), 

722 "target_cutoff_length": self.get_smac2_target_cutoff_length(), 

723 "use_cpu_time_in_tunertime": self.get_smac2_use_cpu_time_in_tunertime(), 

724 "max_iterations": self.get_smac2_max_iterations() 

725 or configurator_settings["max_iterations"], 

726 }) 

727 if configurator_name == cim.IRACE.__name__: 

728 # Return all settings from the IRACE section 

729 configurator_settings.update({ 

730 "solver_calls": self.get_irace_max_experiments(), 

731 "max_time": self.get_irace_max_time(), 

732 "first_test": self.get_irace_first_test(), 

733 "mu": self.get_irace_mu(), 

734 "max_iterations": self.get_irace_max_iterations() 

735 or configurator_settings["max_iterations"], 

736 }) 

737 if (configurator_settings["solver_calls"] == 0 

738 and configurator_settings["max_time"] == 0): # Default to base 

739 configurator_settings["solver_calls"] =\ 

740 self.get_configurator_solver_calls() 

741 return configurator_settings 

742 

743 def set_configurator_solver_calls( 

744 self: Settings, value: int = DEFAULT_configurator_solver_calls, 

745 origin: SettingState = SettingState.DEFAULT) -> None: 

746 """Set the number of solver calls.""" 

747 section = "configuration" 

748 name = "solver_calls" 

749 

750 if value is not None and self.__check_setting_state( 

751 self.__config_solver_calls_set, origin, name): 

752 self.__init_section(section) 

753 self.__config_solver_calls_set = origin 

754 self.__settings[section][name] = str(value) 

755 

756 def get_configurator_solver_calls(self: Settings) -> int | None: 

757 """Return the maximum number of solver calls the configurator can do.""" 

758 if self.__config_solver_calls_set == SettingState.NOT_SET: 

759 self.set_configurator_solver_calls() 

760 

761 return int(self.__settings["configuration"]["solver_calls"]) 

762 

763 def set_configurator_number_of_runs( 

764 self: Settings, value: int = DEFAULT_configurator_number_of_runs, 

765 origin: SettingState = SettingState.DEFAULT) -> None: 

766 """Set the number of configuration runs.""" 

767 section = "configuration" 

768 name = "number_of_runs" 

769 

770 if value is not None and self.__check_setting_state( 

771 self.__config_number_of_runs_set, origin, name): 

772 self.__init_section(section) 

773 self.__config_number_of_runs_set = origin 

774 self.__settings[section][name] = str(value)