Coverage for src \ nuremics \ core \ workflow.py: 81%

1from __future__ import annotations 

2 

3import json 

4import os 

5import pathlib 

6import shutil 

7import sys 

8from importlib.resources import files 

9from pathlib import Path 

10 

11import numpy as np 

12import pandas as pd 

13from termcolor import colored 

14 

15from .process import Process 

16from .utils import ( 

17 extract_analysis, 

18 extract_inputs_and_types, 

19 extract_outputs, 

20 get_self_method_calls, 

21 only_function_calls, 

22) 

23 

24 

25class WorkFlow: 

26 

27 def __init__( 

28 self, 

29 app_name: str, 

30 config_path: Path, 

31 workflow: list, 

32 silent: bool = False, 

33 ) -> None: 

34 

35 # -------------------- # 

36 # Initialize variables # 

37 # -------------------- # 

38 self.app_name = app_name 

39 self.config_path = config_path 

40 self.list_workflow = workflow 

41 self.list_processes = [] 

42 self.dict_inputs = {} 

43 self.dict_datasets = {} 

44 self.dict_studies = {} 

45 self.dict_process = {} 

46 self.dict_analysis = {} 

47 self.user_params = [] 

48 self.user_paths = [] 

49 self.output_paths = [] 

50 self.overall_analysis = [] 

51 self.params_type = {} 

52 self.operations_by_process = {} 

53 self.inputs_by_process = {} 

54 self.params_by_process = {} 

55 self.paths_by_process = {} 

56 self.outputs_by_process = {} 

57 self.analysis_by_process = {} 

58 self.settings_by_process = {} 

59 self.params_plug = {} 

60 self.paths_plug = {} 

61 self.outputs_plug = {} 

62 self.analysis_plug = {} 

63 self.studies_modif = {} 

64 self.studies_messages = {} 

65 self.studies_config = {} 

66 self.fixed_params_messages = {} 

67 self.fixed_params_config = {} 

68 self.fixed_paths_messages = {} 

69 self.fixed_paths_config = {} 

70 self.variable_params_messages = {} 

71 self.variable_params_config = {} 

72 self.variable_paths_messages = {} 

73 self.variable_paths_config = {} 

74 self.fixed_params = {} 

75 self.fixed_paths = {} 

76 self.variable_params = {} 

77 self.variable_paths = {} 

78 self.dict_fixed_params = {} 

79 self.dict_variable_params = {} 

80 self.dict_user_paths = {} 

81 self.dict_paths = {} 

82 self.diagram = {} 

83 self.silent = silent 

84 

85 # ------------------------------------ # 

86 # Define and create nuremics directory # 

87 # ------------------------------------ # 

88 self.config_path.mkdir( 

89 exist_ok=True, 

90 parents=True, 

91 ) 

92 

93 # -------------------- # 

94 # Create settings file # 

95 # -------------------- # 

96 settings_file = self.config_path / "settings.json" 

97 if not settings_file.exists(): 

98 dict_settings = { 

99 "default_working_dir": None, 

100 "apps": {}, 

101 } 

102 with open(settings_file, "w") as f: 

103 json.dump(dict_settings, f, indent=4) 

104 

105 # -------------------------- # 

106 # Define settings dictionary # 

107 # -------------------------- # 

108 with open(settings_file) as f: 

109 self.dict_settings = json.load(f) 

110 

111 # ------------------------------- # 

112 # Initialize application settings # 

113 # ------------------------------- # 

114 if self.app_name not in self.dict_settings["apps"]: 

115 self.dict_settings["apps"][self.app_name] = { 

116 "working_dir": None, 

117 } 

118 

119 # ----------------------------- # 

120 # Set default working directory # 

121 # ----------------------------- # 

122 if self.dict_settings["default_working_dir"] is None: 

123 for _, value in self.dict_settings["apps"].items(): 

124 if value["working_dir"] is not None: 

125 self.dict_settings["default_working_dir"] = value["working_dir"] 

126 break 

127 

128 # ------------------- # 

129 # Write settings file # 

130 # ------------------- # 

131 with open(settings_file, "w") as f: 

132 json.dump(self.dict_settings, f, indent=4) 

133 

134 # ------------------------ # 

135 # Define list of processes # 

136 # ------------------------ # 

137 for proc in self.list_workflow: 

138 self.list_processes.append(proc["process"].__name__) 

139 

140 def print_logo(self) -> None: 

141 

142 ascii_logo_path: str = files("nuremics.resources").joinpath("logo.txt") 

143 f = open(ascii_logo_path) 

144 for line in f: 

145 lines = f.readlines() 

146 print() 

147 for line in lines: 

148 print(colored(line.rstrip(), "yellow")) 

149 

150 def print_application(self) -> None: 

151 

152 # Printing 

153 print() 

154 print( 

155 colored("> APPLICATION <", "blue", attrs=["reverse"]), 

156 ) 

157 print() 

158 print( 

159 colored("| Workflow |", "magenta"), 

160 ) 

161 print( 

162 colored(f"{self.app_name}_____", "blue"), 

163 ) 

164 

165 # Define number of spaces taken by the workflow print 

166 nb_spaces_app = len(self.app_name) + 5 

167 

168 # Print diagram of processes and operations 

169 error = False 

170 for i, proc in enumerate(self.list_workflow): 

171 

172 proc_name = proc["process"].__name__ 

173 process = proc["process"] 

174 this_process: Process = process() 

175 

176 # Define number of spaces taken by the application print 

177 nb_spaces_proc = len(proc_name) + 10 

178 

179 # Get list of operations for current process 

180 self.operations_by_process[proc_name] = get_self_method_calls(this_process.__class__) 

181 

182 # Test if process call contains only call to operations 

183 valid_call = only_function_calls( 

184 method=this_process.__call__, 

185 allowed_methods=self.operations_by_process[proc_name], 

186 ) 

187 

188 # Printing 

189 if valid_call: 

190 print( 

191 colored(" " * nb_spaces_app + f"|_____{proc_name}_____", "blue"), 

192 ) 

193 for op_name in self.operations_by_process[proc_name]: 

194 

195 if i < len(self.list_workflow) - 1: 

196 text = " " * nb_spaces_app + "|" + " " * nb_spaces_proc + f"|_____{op_name}" 

197 else: 

198 text = " " * (nb_spaces_app + 1) + " " * nb_spaces_proc + f"|_____{op_name}" 

199 

200 # Printing 

201 print( 

202 colored(text, "blue"), 

203 ) 

204 else: 

205 print( 

206 colored(" " * nb_spaces_app + f"|_____{proc_name}_____", "blue") + 

207 colored("(X)", "red"), 

208 ) 

209 error = True 

210 

211 if i < len(self.list_workflow) - 1: 

212 print( 

213 colored(" " * nb_spaces_app + "|", "blue"), 

214 ) 

215 

216 if error: 

217 print() 

218 print(colored("(X) Each process must only call its internal function(s):", "red")) 

219 print() 

220 print(colored(" def __call__(self):", "red")) 

221 print(colored(" super().__call__()", "red")) 

222 print() 

223 print(colored(" self.operation1()", "red")) 

224 print(colored(" self.operation2()", "red")) 

225 print(colored(" self.operation3()", "red")) 

226 print(colored(" ...", "red")) 

227 sys.exit(1) 

228 

229 def set_working_directory(self) -> None: 

230 

231 # --------------------- # 

232 # Set working directory # 

233 # --------------------- # 

234 settings_file = self.config_path / "settings.json" 

235 if self.dict_settings["apps"][self.app_name]["working_dir"] is None: 

236 print() 

237 print(colored(f'(X) Please define {self.app_name} "working_dir" in file :', "red")) 

238 print(colored(f"> {settings_file}", "red")) 

239 sys.exit(1) 

240 

241 self.working_dir = Path(self.dict_settings["apps"][self.app_name]["working_dir"]) / self.app_name 

242 

243 # ------------------- # 

244 # Write settings file # 

245 # ------------------- # 

246 with open(settings_file, "w") as f: 

247 json.dump(self.dict_settings, f, indent=4) 

248 

249 # ------------------------ # 

250 # Create working directory # 

251 # ------------------------ # 

252 self.working_dir.mkdir( 

253 exist_ok=True, 

254 parents=True, 

255 ) 

256 

257 # ----------------------- # 

258 # Go to working directory # 

259 # ----------------------- # 

260 os.chdir(self.working_dir) 

261 

262 def get_inputs(self) -> None: 

263 

264 for proc in self.list_workflow: 

265 

266 process = proc["process"] 

267 name = proc["process"].__name__ 

268 this_process: Process = process() 

269 

270 self.inputs_by_process[name] = extract_inputs_and_types(this_process) 

271 self.analysis_by_process[name] = extract_analysis(this_process) 

272 

273 if "settings" in proc: 

274 self.settings_by_process[name] = proc["settings"] 

275 

276 self.params_by_process[name] = {} 

277 self.paths_by_process[name] = [] 

278 self.params_plug[name] = {} 

279 self.paths_plug[name] = {} 

280 self.analysis_plug[name] = {} 

281 

282 for key, value_type in self.inputs_by_process[name].items(): 

283 

284 # Get the module and type name 

285 module_name = value_type.__module__ 

286 type_name = value_type.__name__ 

287 

288 if module_name == "builtins": 

289 type = type_name 

290 else: 

291 type = f"{module_name}.{type_name}" 

292 

293 if key not in self.analysis_by_process[name]: 

294 

295 if issubclass(value_type, pathlib.Path): 

296 self.paths_by_process[name].append(key) 

297 if ("user_paths" in proc) and (key in proc["user_paths"]): 

298 self.paths_plug[name][key] = [proc["user_paths"][key], "user_paths"] 

299 elif ("required_paths" in proc) and (key in proc["required_paths"]): 

300 self.paths_plug[name][key] = [proc["required_paths"][key], "required_paths"] 

301 else: 

302 self.paths_plug[name][key] = None 

303 

304 else: 

305 self.params_by_process[name][key] = [value_type, type] 

306 if ("user_params" in proc) and (key in proc["user_params"]): 

307 self.params_plug[name][key] = [proc["user_params"][key], "user_params"] 

308 elif ("hard_params" in proc) and (key in proc["hard_params"]): 

309 self.params_plug[name][key] = [proc["hard_params"][key], "hard_params"] 

310 else: 

311 self.params_plug[name][key] = None 

312 

313 elif ("overall_analysis" in proc) and (key in proc["overall_analysis"]): 

314 self.analysis_plug[name][key] = proc["overall_analysis"][key] 

315 else: 

316 self.analysis_plug[name][key] = None 

317 

318 def get_outputs(self) -> None: 

319 

320 for proc in self.list_workflow: 

321 

322 process = proc["process"] 

323 name = proc["process"].__name__ 

324 this_process: Process = process() 

325 

326 self.outputs_by_process[name] = extract_outputs(this_process) 

327 self.outputs_plug[name] = {} 

328 

329 for output in self.outputs_by_process[name]: 

330 if ("output_paths" in proc) and (output in proc["output_paths"]): 

331 self.outputs_plug[name][output] = proc["output_paths"][output] 

332 else: 

333 self.outputs_plug[name][output] = None 

334 

335 def init_config(self) -> None: 

336 

337 for _, process in enumerate(self.list_workflow): 

338 

339 name = process["process"].__name__ 

340 

341 # Define list of user parameters 

342 if "user_params" in process: 

343 for key, value in process["user_params"].items(): 

344 if key in self.params_by_process[name]: 

345 self.user_params.append(value) 

346 else: 

347 print() 

348 print(colored(f'(X) {key} defined in "user_params" is not an input parameter of {name}.', "red")) 

349 sys.exit(1) 

350 

351 # Check on hard parameters 

352 if "hard_params" in process: 

353 for key, _ in process["hard_params"].items(): 

354 if key not in self.params_by_process[name]: 

355 print() 

356 print(colored(f'(X) {key} defined in "hard_params" is not an input parameter of {name}.', "red")) 

357 sys.exit(1) 

358 

359 # Define list of user paths 

360 if "user_paths" in process: 

361 for key, value in process["user_paths"].items(): 

362 if key in self.paths_by_process[name]: 

363 self.user_paths.append(value) 

364 else: 

365 print() 

366 print(colored(f"(X) {key} is not an input path of {name}.", "red")) 

367 sys.exit(1) 

368 

369 # Check on required paths 

370 if "required_paths" in process: 

371 for _, value in process["required_paths"].items(): 

372 if value not in self.output_paths: 

373 print() 

374 print(colored(f'(X) {value} defined in {name} "required_paths" must be defined in previous process "output_paths".', "red")) 

375 sys.exit(1) 

376 

377 # Define list of output paths 

378 if "output_paths" in process: 

379 for key, value in process["output_paths"].items(): 

380 if key in self.outputs_by_process[name]: 

381 if value in self.output_paths: 

382 print() 

383 print(colored(f'(X) {value} is defined twice in "output_paths".', "red")) 

384 sys.exit(1) 

385 else: 

386 self.output_paths.append(value) 

387 else: 

388 print() 

389 print(colored(f"(X) {key} is not an output path of {name}.", "red")) 

390 sys.exit(1) 

391 

392 # Define list of outputs for analysis 

393 if "overall_analysis" in process: 

394 for key, value in process["overall_analysis"].items(): 

395 if key in self.analysis_by_process[name]: 

396 self.overall_analysis.append(value) 

397 else: 

398 print() 

399 print(colored(f"(X) {key} is not an output analysis of {name}.", "red")) 

400 sys.exit(1) 

401 

402 if value not in self.output_paths: 

403 print() 

404 print(colored(f'(X) {value} defined in {name} "overall_analysis" must be defined in previous process "output_paths".', "red")) 

405 sys.exit(1) 

406 

407 # Delete duplicates 

408 self.user_params = list(dict.fromkeys(self.user_params)) 

409 self.user_paths = list(dict.fromkeys(self.user_paths)) 

410 self.overall_analysis = list(dict.fromkeys(self.overall_analysis)) 

411 

412 def print_processes(self) -> None: 

413 

414 for proc in self.list_workflow: 

415 

416 name = proc["process"].__name__ 

417 

418 # Printing 

419 print() 

420 print( 

421 colored(f"| {name} |", "magenta"), 

422 ) 

423 

424 # ---------------- # 

425 # Input parameters # 

426 # ---------------- # 

427 print( 

428 colored("> Input Parameter(s) :", "blue"), 

429 ) 

430 if len(self.params_by_process[name]) == 0: 

431 print( 

432 colored("None.", "blue"), 

433 ) 

434 else: 

435 lines_proc = [] 

436 lines_user = [] 

437 error = False 

438 for key, value in self.params_by_process[name].items(): 

439 

440 # Process 

441 text_type_proc = f"({value[1]})" 

442 text_variable_proc = key 

443 lines_proc.append((text_type_proc, text_variable_proc)) 

444 

445 # User 

446 if self.params_plug[name][key] is not None: 

447 text_variable_user = str(self.params_plug[name][key][0]) 

448 text_definition_user = f"({self.params_plug[name][key][1]})" 

449 lines_user.append((text_variable_user, text_definition_user)) 

450 else: 

451 lines_user.append(("Not defined", "(X)")) 

452 error = True 

453 

454 type_proc_width = max(len(t) for t, _ in lines_proc) + 1 

455 variable_proc_width = max(len(p) for _, p in lines_proc) + 1 

456 variable_user_width = max(len(t) for t, _ in lines_user) + 1 

457 definition_user_width = max(len(p) for _, p in lines_user) + 1 

458 

459 for (type_proc, var_proc), (user_var, user_def) in zip(lines_proc, lines_user): 

460 proc_str = type_proc.ljust(type_proc_width) + var_proc.ljust(variable_proc_width) + "-----|" 

461 user_str = "|----- " + user_var.ljust(variable_user_width) + user_def.ljust(definition_user_width) 

462 if "(X)" in user_str: 

463 color = "red" 

464 else: 

465 color = "green" 

466 print(colored(proc_str, "blue") + colored(user_str, color)) 

467 

468 if error: 

469 print() 

470 print(colored('(X) Please define all input parameters either in "user_params" or "hard_params".', "red")) 

471 sys.exit(1) 

472 

473 # ----------- # 

474 # Input paths # 

475 # ----------- # 

476 print( 

477 colored("> Input Path(s) :", "blue"), 

478 ) 

479 if len(self.paths_by_process[name]) == 0: 

480 print( 

481 colored("None.", "blue"), 

482 ) 

483 else: 

484 lines_proc = [] 

485 lines_user = [] 

486 error = False 

487 for path in self.paths_by_process[name]: 

488 

489 # Process 

490 lines_proc.append(path) 

491 

492 # User 

493 if self.paths_plug[name][path] is not None: 

494 text_variable_user = self.paths_plug[name][path][0] 

495 text_definition_user = f"({self.paths_plug[name][path][1]})" 

496 lines_user.append((text_variable_user, text_definition_user)) 

497 else: 

498 lines_user.append(("Not defined", "(X)")) 

499 error = True 

500 

501 proc_width = max(len(t) for t in lines_proc) + 1 

502 variable_user_width = max(len(t) for t, _ in lines_user) + 1 

503 definition_user_width = max(len(p) for _, p in lines_user) + 1 

504 

505 for (proc), (user_var, user_def) in zip(lines_proc, lines_user): 

506 proc_str = proc.ljust(proc_width) + "-----|" 

507 user_str = "|----- " + user_var.ljust(variable_user_width) + user_def.ljust(definition_user_width) 

508 if "(X)" in user_str: 

509 color = "red" 

510 else: 

511 color = "green" 

512 print(colored(proc_str, "blue") + colored(user_str, color)) 

513 

514 if error: 

515 print() 

516 print(colored('(X) Please define all input paths either in "user_paths" or "required_paths".', "red")) 

517 sys.exit(1) 

518 

519 # ---------------- # 

520 # Input analysis # 

521 # ---------------- # 

522 print( 

523 colored("> Input Analysis :", "blue"), 

524 ) 

525 if len(self.analysis_by_process[name]) == 0: 

526 print( 

527 colored("None.", "blue"), 

528 ) 

529 else: 

530 lines_proc = [] 

531 lines_user = [] 

532 error = False 

533 for out in self.analysis_by_process[name]: 

534 

535 # Process 

536 lines_proc.append(out) 

537 

538 # User 

539 if self.analysis_plug[name][out] is not None: 

540 text_variable_user = self.analysis_plug[name][out] 

541 text_definition_user = "(overall_analysis)" 

542 lines_user.append((text_variable_user, text_definition_user)) 

543 else: 

544 lines_user.append(("Not defined", "(X)")) 

545 error = True 

546 

547 proc_width = max(len(t) for t in lines_proc) + 1 

548 variable_user_width = max(len(t) for t, _ in lines_user) + 1 

549 definition_user_width = max(len(p) for _, p in lines_user) + 1 

550 

551 for (proc), (user_var, user_def) in zip(lines_proc, lines_user): 

552 proc_str = proc.ljust(proc_width) + "-----|" 

553 user_str = "|----- " + user_var.ljust(variable_user_width) + user_def.ljust(definition_user_width) 

554 if "(X)" in user_str: 

555 color = "red" 

556 else: 

557 color = "green" 

558 print(colored(proc_str, "blue") + colored(user_str, color)) 

559 

560 if error: 

561 print() 

562 print(colored('(X) Please define all output analysis in "overall_analysis".', "red")) 

563 sys.exit(1) 

564 

565 # ------------ # 

566 # Output paths # 

567 # ------------ # 

568 print( 

569 colored("> Output Path(s) :", "blue"), 

570 ) 

571 if len(self.outputs_by_process[name]) == 0: 

572 print( 

573 colored("None.", "blue"), 

574 ) 

575 else: 

576 lines_proc = [] 

577 lines_user = [] 

578 error = False 

579 for path in self.outputs_by_process[name]: 

580 

581 # Process 

582 lines_proc.append(path) 

583 

584 # User 

585 if self.outputs_plug[name][path] is not None: 

586 text_variable_user = self.outputs_plug[name][path] 

587 text_definition_user = "(output_paths)" 

588 lines_user.append((text_variable_user, text_definition_user)) 

589 else: 

590 lines_user.append(("Not defined", "(X)")) 

591 error = True 

592 

593 proc_width = max(len(t) for t in lines_proc) + 1 

594 variable_user_width = max(len(t) for t, _ in lines_user) + 1 

595 definition_user_width = max(len(p) for _, p in lines_user) + 1 

596 

597 for (proc), (user_var, user_def) in zip(lines_proc, lines_user): 

598 proc_str = proc.ljust(proc_width) + "-----|" 

599 user_str = "|----- " + user_var.ljust(variable_user_width) + user_def.ljust(definition_user_width) 

600 if "(X)" in user_str: 

601 color = "red" 

602 else: 

603 color = "green" 

604 print(colored(proc_str, "blue") + colored(user_str, color)) 

605 

606 if error: 

607 print() 

608 print(colored('(X) Please define all output paths in "output_paths".', "red")) 

609 sys.exit(1) 

610 

611 def set_user_params_types(self) -> None: 

612 

613 # Gather all types of parameters 

614 for proc, params in self.params_by_process.items(): 

615 for param, type in params.items(): 

616 user_param = self.params_plug[proc][param][0] 

617 if user_param in self.user_params: 

618 if (user_param in self.params_type) and (self.params_type[user_param][0] != type[0]): 

619 print() 

620 print(colored(f"(X) {user_param} is defined both as ({self.params_type[user_param][1]}) and ({type[1]}) :", "red")) 

621 print(colored('> Please consider defining a new user parameter in "user_params".', "red")) 

622 sys.exit(1) 

623 self.params_type[user_param] = type 

624 

625 def print_io(self) -> None: 

626 

627 # Printing 

628 print() 

629 print( 

630 colored("> INPUTS <", "blue", attrs=["reverse"]), 

631 ) 

632 

633 # Print input parameters 

634 print() 

635 print( 

636 colored("| User Parameters |", "magenta"), 

637 ) 

638 for param, type in self.params_type.items(): 

639 print( 

640 colored(f"> {param} ({type[1]})", "blue"), 

641 ) 

642 if len(list(self.params_type.items())) == 0: 

643 print( 

644 colored("None.", "blue"), 

645 ) 

646 

647 # Print input paths 

648 print() 

649 print( 

650 colored("| User Paths |", "magenta"), 

651 ) 

652 for path in self.user_paths: 

653 print( 

654 colored(f"> {path}", "blue"), 

655 ) 

656 if len(self.user_paths) == 0: 

657 print( 

658 colored("None.", "blue"), 

659 ) 

660 

661 # Printing 

662 print() 

663 print( 

664 colored("> OUTPUTS <", "blue", attrs=["reverse"]), 

665 ) 

666 print() 

667 for path in self.output_paths: 

668 print( 

669 colored(f"> {path}", "blue"), 

670 ) 

671 if len(self.output_paths) == 0: 

672 print( 

673 colored("None.", "blue"), 

674 ) 

675 

676 def define_studies(self) -> None: 

677 

678 # ---------------------------- # 

679 # Initialize studies json file # 

680 # ---------------------------- # 

681 self.studies_file = self.working_dir / "studies.json" 

682 if self.studies_file.exists(): 

683 with open(self.studies_file) as f: 

684 self.dict_studies = json.load(f) 

685 else: 

686 self.dict_studies["studies"] = [] 

687 self.dict_studies["config"] = {} 

688 with open(self.studies_file, "w") as f: 

689 json.dump(self.dict_studies, f, indent=4) 

690 

691 print() 

692 print( 

693 colored("> STUDIES <", "blue", attrs=["reverse"]), 

694 ) 

695 

696 if len(self.dict_studies["studies"]) == 0: 

697 print() 

698 print(colored("(X) Please declare at least one study in file :", "red")) 

699 print(colored(f"> {self.studies_file}", "red")) 

700 sys.exit(1) 

701 else: 

702 self.studies = self.dict_studies["studies"] 

703 

704 def init_studies(self) -> None: 

705 

706 # Clean studies 

707 for study in list(self.dict_studies["config"].keys()): 

708 if study not in self.studies: 

709 del self.dict_studies["config"][study] 

710 

711 # Clean input parameters 

712 for study in list(self.dict_studies["config"].keys()): 

713 for param in list(self.dict_studies["config"][study]["user_params"]): 

714 if param not in self.user_params: 

715 del self.dict_studies["config"][study]["user_params"][param] 

716 

717 # Clean input paths 

718 for study in list(self.dict_studies["config"].keys()): 

719 for path in list(self.dict_studies["config"][study]["user_paths"]): 

720 if path not in self.user_paths: 

721 del self.dict_studies["config"][study]["user_paths"][path] 

722 

723 # Clean output paths 

724 for study in list(self.dict_studies["config"].keys()): 

725 for path in list(self.dict_studies["config"][study]["clean_outputs"]): 

726 if path not in self.output_paths: 

727 del self.dict_studies["config"][study]["clean_outputs"][path] 

728 

729 # Initialize input parameters/paths 

730 for study in self.studies: 

731 

732 if study not in self.dict_studies["config"]: 

733 self.dict_studies["config"][study] = { 

734 "execute": True, 

735 "user_params": {}, 

736 "user_paths": {}, 

737 "clean_outputs": {}, 

738 } 

739 

740 for param in self.user_params: 

741 if param not in self.dict_studies["config"][study]["user_params"]: