refac: abstracted filepath management functionality as a Mixin to be used in file-base registries. Created ExperimentRegistry abstract and File-based concrete classes. Renamed registries' interface to add/get_*_key. abstracted registry logging to be a function in the logger module.

tests: added unit tests for experiment file registry

Author: pabloitu

floatcsep/evaluation.py

@@ -287,7 +287,7 @@ def plot_results(
                 # Regular consistency/comparative test plots (e.g., many models)
                 try:
                     for time_str in timewindow:
-                        fig_path = registry.get_figure(time_str, self.name)
+                        fig_path = registry.get_figure_key(time_str, self.name)
                         results = self.read_results(time_str, models)
                         ax = func(results, plot_args=fargs, **fkwargs)
                         if "code" in fargs:
@@ -307,7 +307,7 @@ def plot_results(
                                 registry.figures[time_str][fig_name] = os.path.join(
                                     time_str, "figures", fig_name
                                 )
-                                fig_path = registry.get_figure(time_str, fig_name)
+                                fig_path = registry.get_figure_key(time_str, fig_name)
                                 ax = func(result, plot_args=fargs, **fkwargs, show=False)
                                 if "code" in fargs:
                                     exec(fargs["code"])
@@ -318,7 +318,7 @@ def plot_results(
                                     pyplot.show()
 
             elif self.type in ["sequential", "sequential_comparative", "batch"]:
-                fig_path = registry.get_figure(timewindow[-1], self.name)
+                fig_path = registry.get_figure_key(timewindow[-1], self.name)
                 results = self.read_results(timewindow[-1], models)
                 ax = func(results, plot_args=fargs, **fkwargs)
 

floatcsep/experiment.py

@@ -25,6 +25,7 @@
     parse_nested_dicts,
 )
 from floatcsep.infrastructure.engine import Task, TaskGraph
+from floatcsep.infrastructure.logger import log_models_tree, log_results_tree
 
 log = logging.getLogger("floatLogger")
 
@@ -118,7 +119,7 @@ def __init__(
         os.makedirs(os.path.join(workdir, rundir), exist_ok=True)
 
         self.name = name if name else "floatingExp"
-        self.registry = ExperimentRegistry(workdir, rundir)
+        self.registry = ExperimentRegistry.factory(workdir=workdir, run_dir=rundir)
         self.results_repo = ResultsRepository(self.registry)
         self.catalog_repo = CatalogRepository(self.registry)
 
@@ -296,7 +297,7 @@ def stage_models(self) -> None:
         log.info("Staging models")
         for i in self.models:
             i.stage(self.time_windows)
-            self.registry.add_forecast_registry(i)
+            self.registry.add_model_registry(i)
 
     def set_tests(self, test_config: Union[str, Dict, List]) -> list:
         """
@@ -379,9 +380,9 @@ def set_tasks(self) -> None:
         self.registry.build_tree(self.time_windows, self.models, self.tests)
 
         log.debug("Pre-run forecast summary")
-        self.registry.log_forecast_trees(self.time_windows)
+        log_models_tree(log, self.registry, self.time_windows)
         log.debug("Pre-run result summary")
-        self.registry.log_results_tree()
+        log_results_tree(log, self.registry)
 
         log.info("Setting up experiment's tasks")
 
@@ -540,9 +541,9 @@ def run(self) -> None:
         self.task_graph.run()
         log.info("Calculation completed")
         log.debug("Post-run forecast registry")
-        self.registry.log_forecast_trees(self.time_windows)
+        log_models_tree(log, self.registry, self.time_windows)
         log.debug("Post-run result summary")
-        self.registry.log_results_tree()
+        log_results_tree(log, self.registry)
 
     def read_results(self, test: Evaluation, window: str) -> List:
         """
@@ -559,7 +560,7 @@ def make_repr(self) -> None:
 
         """
         log.info("Creating reproducibility config file")
-        repr_config = self.registry.get("repr_config")
+        repr_config = self.registry.get_attr("repr_config")
 
         # Dropping region to results folder if it is a file
         region_path = self.region_config.get("path", False)
@@ -801,8 +802,8 @@ def get_filecomp(self):
                 for tw in win_orig:
                     results[test.name][tw] = dict.fromkeys(models_orig)
                     for model in models_orig:
-                        orig_path = self.original.registry.get_result(tw, test, model)
-                        repr_path = self.reproduced.registry.get_result(tw, test, model)
+                        orig_path = self.original.registry.get_result_key(tw, test, model)
+                        repr_path = self.reproduced.registry.get_result_key(tw, test, model)
 
                         results[test.name][tw][model] = {
                             "hash": (self.get_hash(orig_path) == self.get_hash(repr_path)),
@@ -811,8 +812,8 @@ def get_filecomp(self):
             else:
                 results[test.name] = dict.fromkeys(models_orig)
                 for model in models_orig:
-                    orig_path = self.original.registry.get_result(win_orig[-1], test, model)
-                    repr_path = self.reproduced.registry.get_result(win_orig[-1], test, model)
+                    orig_path = self.original.registry.get_result_key(win_orig[-1], test, model)
+                    repr_path = self.reproduced.registry.get_result_key(win_orig[-1], test, model)
                     results[test.name][model] = {
                         "hash": (self.get_hash(orig_path) == self.get_hash(repr_path)),
                         "byte2byte": filecmp.cmp(orig_path, repr_path),

floatcsep/infrastructure/logger.py

@@ -60,3 +60,74 @@ def set_console_log_level(log_level):
     for handler in logger.handlers:
         if isinstance(handler, logging.StreamHandler):
             handler.setLevel(log_level)
+
+
+
+
+def log_models_tree(log, experiment_registry, time_windows):
+    """
+    Logs the forecasts for all models managed by this ExperimentFileRegistry.
+    """
+    log.debug("===================")
+    log.debug(f" Total Time Windows: {len(time_windows)}")
+    for model_name, registry in experiment_registry.model_registries.items():
+        log.debug(f"  Model: {model_name}")
+        exists_group = []
+        not_exist_group = []
+
+        for timewindow, filepath in registry.forecasts.items():
+            if registry.forecast_exists(timewindow):
+                exists_group.append(timewindow)
+            else:
+                not_exist_group.append(timewindow)
+
+        log.debug(f"    Existing forecasts: {len(exists_group)}")
+        log.debug(f"    Missing forecasts: {len(not_exist_group)}")
+        for timewindow in not_exist_group:
+            log.debug(f"      Time Window: {timewindow}")
+    log.debug("===================")
+
+
+def log_results_tree(log, experiment_registry):
+    """
+    Logs a summary of the results dictionary, sorted by test.
+    For each test and time window, it logs whether all models have results,
+    or if some results are missing, and specifies which models are missing.
+    """
+    log.debug("===================")
+
+    total_results = results_exist_count = results_not_exist_count = 0
+
+    # Get all unique test names and sort them
+    all_tests = sorted(
+        {test_name for tests in experiment_registry.results.values() for test_name in tests}
+    )
+
+    for test_name in all_tests:
+        log.debug(f"Test: {test_name}")
+        for timewindow, tests in experiment_registry.results.items():
+            if test_name in tests:
+                models = tests[test_name]
+                missing_models = []
+
+                for model_name, result_path in models.items():
+                    total_results += 1
+                    result_full_path = experiment_registry.get_result_key(timewindow, test_name, model_name)
+                    if os.path.exists(result_full_path):
+                        results_exist_count += 1
+                    else:
+                        results_not_exist_count += 1
+                        missing_models.append(model_name)
+
+                if not missing_models:
+                    log.debug(f"  Time Window: {timewindow} - All models evaluated.")
+                else:
+                    log.debug(
+                        f"  Time Window: {timewindow} - Missing results for models: "
+                        f"{', '.join(missing_models)}"
+                    )
+
+    log.debug(f"Total Results: {total_results}")
+    log.debug(f"Results that Exist: {results_exist_count}")
+    log.debug(f"Results that Do Not Exist: {results_not_exist_count}")
+    log.debug("===================")