Coverage for sparkle/CLI/add_solver.py: 83%

1#!/usr/bin/env python3 

2"""Sparkle command to add a solver to the Sparkle platform.""" 

3import os 

4import stat 

5import sys 

6import argparse 

7import shutil 

8from pathlib import Path 

9 

10from sparkle.tools.parameters import PCSConvention 

11 

12from sparkle.platform import file_help as sfh 

13from sparkle.CLI.help import global_variables as gv 

14from sparkle.structures import PerformanceDataFrame 

15from sparkle.solver import Solver, verifiers 

16from sparkle.CLI.help import logging as sl 

17from sparkle.CLI.initialise import check_for_initialise 

18from sparkle.CLI.help import argparse_custom as ac 

19 

20 

21def parser_function() -> argparse.ArgumentParser: 

22 """Define the command line arguments.""" 

23 parser = argparse.ArgumentParser( 

24 description="Add a solver to the Sparkle platform.") 

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

26 **ac.DeterministicArgument.kwargs) 

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

28 **ac.SolutionVerifierArgument.kwargs) 

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

30 **ac.NicknameSolverArgument.kwargs) 

31 parser.add_argument(*ac.SolverPathArgument.names, **ac.SolverPathArgument.kwargs) 

32 parser.add_argument(*ac.SkipChecksArgument.names, **ac.SkipChecksArgument.kwargs) 

33 parser.add_argument(*ac.NoCopyArgument.names, **ac.NoCopyArgument.kwargs) 

34 return parser 

35 

36 

37def main(argv: list[str]) -> None: 

38 """Main function of the command.""" 

39 # Log command call 

40 sl.log_command(sys.argv) 

41 check_for_initialise() 

42 

43 # Define command line arguments 

44 parser = parser_function() 

45 

46 # Process command line arguments 

47 args = parser.parse_args(argv) 

48 solver_source = Path(args.solver_path) 

49 deterministic = args.deterministic 

50 solution_verifier = args.solution_verifier 

51 

52 if not solver_source.exists(): 

53 print(f'Solver path "{solver_source}" does not exist!') 

54 sys.exit(-1) 

55 

56 # Make sure it is pointing to the verifiers module 

57 if solution_verifier: 

58 if Path(solution_verifier).is_file(): # File verifier 

59 solution_verifier = (verifiers.SolutionFileVerifier.__name__, 

60 solution_verifier) 

61 elif solution_verifier not in verifiers.mapping: 

62 print(f"ERROR: Unknown solution verifier {solution_verifier}!") 

63 sys.exit(-1) 

64 

65 nickname = args.nickname 

66 

67 if args.run_checks: 

68 print("Running checks...") 

69 solver = Solver(Path(solver_source)) 

70 if solver.pcs_file is None: 

71 print("None or multiple .pcs files found. Solver " 

72 "is not valid for configuration.") 

73 else: 

74 print(f"PCS file detected: {solver.pcs_file.name}. ", end="") 

75 if solver.read_pcs_file(): 

76 print("Can read the pcs file.") 

77 else: 

78 print("WARNING: Can not read the provided pcs file format.") 

79 

80 configurator_wrapper_path = solver_source / Solver.wrapper 

81 if not (configurator_wrapper_path.is_file() 

82 and os.access(configurator_wrapper_path, os.X_OK)): 

83 print(f"WARNING: Solver {solver_source.name} does not have a solver wrapper " 

84 f"(Missing file {Solver.wrapper}) or is not executable. ") 

85 

86 # Start add solver 

87 solver_directory = gv.settings().DEFAULT_solver_dir / solver_source.name 

88 if solver_directory.exists(): 

89 print(f"ERROR: Solver {solver_source.name} already exists! " 

90 "Can not add new solver.") 

91 sys.exit(-1) 

92 if args.no_copy: 

93 print(f"Creating symbolic link from {solver_source} " 

94 f"to {solver_directory}...") 

95 if not os.access(solver_source, os.W_OK): 

96 raise PermissionError("Sparkle does not have the right to write to the " 

97 "destination folder.") 

98 solver_directory.symlink_to(solver_source.absolute()) 

99 else: 

100 print(f"Copying {solver_source.name} to platform...") 

101 solver_directory.mkdir(parents=True) 

102 shutil.copytree(solver_source, solver_directory, dirs_exist_ok=True) 

103 

104 # Save the deterministic bool in the solver 

105 with (solver_directory / Solver.meta_data).open("w+") as fout: 

106 fout.write(str({"deterministic": deterministic, 

107 "verifier": solution_verifier})) 

108 

109 # Add RunSolver executable to the solver 

110 runsolver_path = gv.settings().DEFAULT_runsolver_exec 

111 if runsolver_path.name in [file.name for file in solver_directory.iterdir()]: 

112 print("Warning! RunSolver executable detected in Solver " 

113 f"{solver_source.name}. This will be replaced with " 

114 f"Sparkle's version of RunSolver. ({runsolver_path})") 

115 runsolver_target = solver_directory / runsolver_path.name 

116 shutil.copyfile(runsolver_path, runsolver_target) 

117 runsolver_target.chmod(os.stat(runsolver_target).st_mode | stat.S_IEXEC) 

118 

119 performance_data = PerformanceDataFrame( 

120 gv.settings().DEFAULT_performance_data_path, 

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

122 performance_data.add_solver(str(solver_directory)) 

123 performance_data.save_csv() 

124 

125 print(f"Adding solver {solver_source.name} done!") 

126 

127 if nickname is not None: 

128 sfh.add_remove_platform_item( 

129 solver_directory, 

130 gv.solver_nickname_list_path, 

131 gv.file_storage_data_mapping[gv.solver_nickname_list_path], 

132 key=nickname) 

133 

134 solver = Solver(solver_directory) # Recreate solver from its new directory 

135 if solver.pcs_file is not None: 

136 # Generate missing PCS files 

137 # TODO: Only generate missing files 

138 print("Generating missing PCS files...") 

139 solver.port_pcs(PCSConvention.IRACE) # Create PCS file for IRACE 

140 print("Generating IRACE done!") 

141 solver.port_pcs(PCSConvention.ParamILS) # Create PCS file for ParamILS 

142 print("Generating ParamILS done!") 

143 

144 # Write used settings to file 

145 gv.settings().write_used_settings() 

146 sys.exit(0) 

147 

148 

149if __name__ == "__main__": 

150 main(sys.argv[1:])