Coverage for sparkle/CLI/initialise.py: 72%
112 statements
« prev ^ index » next coverage.py v7.8.0, created at 2025-04-13 10:34 +0000
1#!/usr/bin/env python3
2"""Command to initialise a Sparkle platform."""
3import subprocess
4import argparse
5import shutil
6import os
7import sys
8import warnings
9from pathlib import Path
11from sparkle.CLI.help import argparse_custom as ac
12from sparkle.CLI.help import snapshot_help as snh
13from sparkle.CLI.help import global_variables as gv
14from sparkle.configurator.implementations.irace import IRACE
15from sparkle.platform import Settings
16from sparkle.structures import PerformanceDataFrame, FeatureDataFrame
19def parser_function() -> argparse.ArgumentParser:
20 """Parse CLI arguments for the initialise command."""
21 parser = argparse.ArgumentParser(
22 description="Initialise the Sparkle platform in the current directory.")
23 parser.add_argument(*ac.DownloadExamplesArgument.names,
24 **ac.DownloadExamplesArgument.kwargs)
25 parser.add_argument(*ac.NoSavePlatformArgument.names,
26 **ac.NoSavePlatformArgument.kwargs)
27 parser.add_argument(*ac.RebuildRunsolverArgument.names,
28 **ac.RebuildRunsolverArgument.kwargs)
29 return parser
32def detect_sparkle_platform_exists(check: callable = all) -> Path:
33 """Return whether a Sparkle platform is currently active.
35 The default working directories are checked for existence, for each directory in the
36 CWD. If any of the parents of the CWD yield true, this path is returned
38 Args:
39 check: Method to check if the working directory exists. Defaults to all.
41 Returns:
42 Path to the Sparkle platform if it exists, None otherwise.
43 """
44 cwd = Path.cwd()
45 while str(cwd) != cwd.root:
46 if check([(cwd / wd).exists() for wd in gv.settings().DEFAULT_working_dirs]):
47 return cwd
48 cwd = cwd.parent
49 return None
52def initialise_irace() -> int:
53 """Initialise IRACE."""
54 if shutil.which("R") is None:
55 warnings.warn("R is not installed, which is required for the IRACE"
56 "configurator. Consider installing R.")
57 return 0
58 print("Initialising IRACE ...")
59 for package in IRACE.package_dependencies:
60 package_name = package.split("_")[0]
61 package_check = subprocess.run(["Rscript", "-e",
62 f'library("{package_name}")'],
63 capture_output=True)
64 if package_check.returncode != 0: # Package is not installed
65 print(f"\t- Installing {package_name} package (IRACE dependency) ...")
66 dependency_install = subprocess.run([
67 "Rscript", "-e",
68 f'install.packages("{(IRACE.configurator_path / package).absolute()}",'
69 f'lib="{IRACE.configurator_path.absolute()}", repos = NULL)'],
70 capture_output=True)
71 if dependency_install.returncode != 0:
72 print(f"An error occured during the installation of {package_name}:\n",
73 dependency_install.stdout.decode(), "\n",
74 dependency_install.stderr.decode(), "\n"
75 "IRACE installation failed!")
76 return dependency_install.returncode
77 # Install IRACE from tarball
78 irace_install = subprocess.run(
79 ["Rscript", "-e",
80 f'install.packages("{IRACE.configurator_package.absolute()}",'
81 f'lib="{IRACE.configurator_path.absolute()}", repos = NULL)'],
82 capture_output=True)
83 if irace_install.returncode != 0 or not IRACE.configurator_executable.exists():
84 print("An error occured during the installation of IRACE:\n",
85 irace_install.stdout.decode(), "\n",
86 irace_install.stderr.decode())
87 return irace_install.returncode
88 print("IRACE installed!")
89 return 0
92def check_for_initialise() -> None:
93 """Function to check if initialize command was executed and execute it otherwise.
95 Args:
96 argv: List of the arguments from the caller.
97 requirements: The requirements that have to be executed before the calling
98 function.
99 """
100 platform_path = detect_sparkle_platform_exists()
101 if platform_path is None:
102 print("-----------------------------------------------")
103 print("No Sparkle platform found; "
104 "The platform will now be initialized automatically.")
105 print("-----------------------------------------------")
106 initialise_sparkle()
107 elif platform_path != Path.cwd():
108 print(f"[WARNING] Sparkle platform found in {platform_path} instead of "
109 f"{Path.cwd()}. Switching to CWD to {platform_path}")
110 os.chdir(platform_path)
113def initialise_sparkle(save_existing_platform: bool = True,
114 download_examples: bool = False,
115 rebuild_runsolver: bool = False) -> None:
116 """Initialize a new Sparkle platform.
118 Args:
119 save_existing_platform: If present, save the current platform as a snapshot.
120 download_examples: Downloads examples from the Sparkle Github.
121 WARNING: May take a some time to complete due to the large amount of data.
122 rebuild_runsolver: Will clean the RunSolver executable and rebuild it.
123 """
124 print("Start initialising Sparkle platform ...")
125 if detect_sparkle_platform_exists(check=all):
126 print("Current Sparkle platform found!")
127 if save_existing_platform:
128 print("Saving as snapshot...")
129 snh.save_current_platform()
130 snh.remove_current_platform(filter=[gv.settings().DEFAULT_settings_dir])
131 print("Your settings directory was not removed.")
133 for working_dir in gv.settings().DEFAULT_working_dirs:
134 working_dir.mkdir(exist_ok=True)
136 # Check if Settings file exists, otherwise initialise a default one
137 if not Path(Settings.DEFAULT_settings_path).exists():
138 print("Settings file does not exist, initializing default settings ...")
139 gv.__settings = Settings(Settings.DEFAULT_example_settings_path)
140 gv.settings().write_settings_ini(Path(Settings.DEFAULT_settings_path))
142 # Initialise latest scenario file
143 gv.ReportingScenario.DEFAULT_reporting_scenario_path.open("w+")
145 # Initialise the FeatureDataFrame
146 FeatureDataFrame(gv.settings().DEFAULT_feature_data_path)
148 # Initialise the Performance DF with the static dimensions
149 # TODO: We have many sparkle settings values regarding ``number of runs''
150 # E.g. configurator, parallel portfolio, and here too. Should we unify this more, or
151 # just make another setting that does this specifically for performance data?
152 PerformanceDataFrame(gv.settings().DEFAULT_performance_data_path,
153 objectives=gv.settings().get_general_sparkle_objectives(),
154 n_runs=1)
156 if rebuild_runsolver:
157 print("Cleaning Runsolver ...")
158 runsolver_clean = subprocess.run(["make", "clean"],
159 cwd=gv.settings().DEFAULT_runsolver_dir,
160 capture_output=True)
161 if runsolver_clean.returncode != 0:
162 warnings.warn(f"[{runsolver_clean.returncode}] Cleaning of Runsolver failed "
163 f"with the following msg: {runsolver_clean.stdout.decode()}")
165 # Check that Runsolver is compiled, otherwise, compile
166 if not gv.settings().DEFAULT_runsolver_exec.exists():
167 print("Runsolver does not exist, trying to compile...")
168 if not (gv.settings().DEFAULT_runsolver_dir / "Makefile").exists():
169 warnings.warn("Runsolver executable doesn't exist and cannot find makefile."
170 " Please verify the contents of the directory: "
171 f"{gv.settings().DEFAULT_runsolver_dir}")
172 else:
173 compile_runsolver =\
174 subprocess.run(["make"],
175 cwd=gv.settings().DEFAULT_runsolver_dir,
176 capture_output=True)
177 if compile_runsolver.returncode != 0:
178 warnings.warn("Compilation of Runsolver failed with the following msg:"
179 f"[{compile_runsolver.returncode}] "
180 f"{compile_runsolver.stderr.decode()}")
181 else:
182 print("Runsolver compiled successfully!")
184 # If Runsolver is compiled, check that it can be executed
185 if gv.settings().DEFAULT_runsolver_exec.exists():
186 runsolver_check = subprocess.run([gv.settings().DEFAULT_runsolver_exec,
187 "--version"],
188 capture_output=True)
189 if runsolver_check.returncode != 0:
190 print("WARNING: Runsolver executable cannot be run successfully. "
191 "Please verify the following error messages:\n"
192 f"{runsolver_check.stderr.decode()}")
194 # Check that java is available for SMAC2
195 if shutil.which("java") is None:
196 # NOTE: An automatic resolution of Java at this point would be good
197 # However, loading modules from Python has thusfar not been successfull.
198 warnings.warn("Could not find Java as an executable! Java 1.8.0_402 is required "
199 "to use SMAC2 or ParamILS as a configurator. "
200 "Consider installing Java.")
202 # Check if IRACE is installed
203 if not IRACE.configurator_executable.exists():
204 initialise_irace()
206 if download_examples:
207 # Download Sparkle examples from Github
208 print("Downloading examples ...")
209 curl = subprocess.Popen(
210 ["curl", "https://codeload.github.com/ADA-research/Sparkle/tar.gz/main"],
211 stdout=subprocess.PIPE)
212 outpath = Path("outfile.tar.gz")
213 with curl.stdout, outpath.open("wb") as outfile:
214 tar = subprocess.Popen(["tar", "-xz", "--strip=1", "Sparkle-main/Examples"],
215 stdin=curl.stdout, stdout=outfile)
216 curl.wait() # Wait for the download to complete
217 tar.wait() # Wait for the extraction to complete
218 outpath.unlink(missing_ok=True)
220 print("New Sparkle platform initialised!")
223def main(argv: list[str]) -> None:
224 """Main function of the command."""
225 # Define command line arguments
226 parser = parser_function()
227 # Process command line arguments
228 args = parser.parse_args(argv)
229 initialise_sparkle(save_existing_platform=args.no_save,
230 download_examples=args.download_examples,
231 rebuild_runsolver=args.rebuild_runsolver)
232 sys.exit(0)
235if __name__ == "__main__":
236 main(sys.argv[1:])