refac: renamed timewindow to time_window across the package. renamed qa tests to e2e

Author: pabloitu

floatcsep/experiment.py

@@ -52,8 +52,8 @@ class Experiment:
             - growth (:class:`str`): `incremental` or `cumulative`
             - offset (:class:`float`): recurrence of forecast creation.
 
-            For further details, see :func:`~floatcsep.utils.timewindows_ti`
-            and :func:`~floatcsep.utils.timewindows_td`
+            For further details, see :func:`~floatcsep.utils.time_windows_ti`
+            and :func:`~floatcsep.utils.time_windows_td`
 
         region_config (dict): Contains all the spatial and magnitude
             specifications. It must contain the following keys:
@@ -143,7 +143,7 @@ def __init__(
         log.info(f"Setting up experiment {self.name}:")
         log.info(f"\tStart: {self.start_date}")
         log.info(f"\tEnd: {self.end_date}")
-        log.info(f"\tTime windows: {len(self.timewindows)}")
+        log.info(f"\tTime windows: {len(self.time_windows)}")
         log.info(f"\tRegion: {self.region.name if self.region else None}")
         log.info(
             f"\tMagnitude range: [{numpy.min(self.magnitudes)},"
@@ -295,7 +295,7 @@ def stage_models(self) -> None:
         """
         log.info("Staging models")
         for i in self.models:
-            i.stage(self.timewindows)
+            i.stage(self.time_windows)
             self.registry.add_forecast_registry(i)
 
     def set_tests(self, test_config: Union[str, Dict, List]) -> list:
@@ -376,17 +376,17 @@ def set_tasks(self) -> None:
         """
 
         # Set the file path structure
-        self.registry.build_tree(self.timewindows, self.models, self.tests)
+        self.registry.build_tree(self.time_windows, self.models, self.tests)
 
         log.debug("Pre-run forecast summary")
-        self.registry.log_forecast_trees(self.timewindows)
+        self.registry.log_forecast_trees(self.time_windows)
         log.debug("Pre-run result summary")
         self.registry.log_results_tree()
 
         log.info("Setting up experiment's tasks")
 
         # Get the time windows strings
-        tw_strings = timewindow2str(self.timewindows)
+        tw_strings = timewindow2str(self.time_windows)
 
         # Prepare the testing catalogs
         task_graph = TaskGraph()
@@ -481,7 +481,7 @@ def set_tasks(self) -> None:
                         )
             # Set up the Sequential_Comparative Scores
             elif test_k.type == "sequential_comparative":
-                tw_strs = timewindow2str(self.timewindows)
+                tw_strs = timewindow2str(self.time_windows)
                 for model_j in self.models:
                     task_k = Task(
                         instance=test_k,
@@ -504,7 +504,7 @@ def set_tasks(self) -> None:
                         )
             # Set up the Batch comparative Scores
             elif test_k.type == "batch":
-                time_str = timewindow2str(self.timewindows[-1])
+                time_str = timewindow2str(self.time_windows[-1])
                 for model_j in self.models:
                     task_k = Task(
                         instance=test_k,
@@ -540,7 +540,7 @@ def run(self) -> None:
         self.task_graph.run()
         log.info("Calculation completed")
         log.debug("Post-run forecast registry")
-        self.registry.log_forecast_trees(self.timewindows)
+        self.registry.log_forecast_trees(self.time_windows)
         log.debug("Post-run result summary")
         self.registry.log_results_tree()
 
@@ -604,7 +604,7 @@ def as_dict(self, extra: Sequence = (), extended=False) -> dict:
             "time_config": {
                 i: j
                 for i, j in self.time_config.items()
-                if (i not in ("timewindows",) or extended)
+                if (i not in ("time_windows",) or extended)
             },
             "region_config": {
                 i: j
@@ -731,7 +731,7 @@ def test_stat(test_orig, test_repr):
 
     def get_results(self):
 
-        win_orig = timewindow2str(self.original.timewindows)
+        win_orig = timewindow2str(self.original.time_windows)
 
         tests_orig = self.original.tests
 
@@ -787,7 +787,7 @@ def get_hash(filename):
 
     def get_filecomp(self):
 
-        win_orig = timewindow2str(self.original.timewindows)
+        win_orig = timewindow2str(self.original.time_windows)
 
         tests_orig = self.original.tests
 

floatcsep/infrastructure/registries.py

@@ -395,12 +395,12 @@ def get_forecast_registry(self, model_name: str) -> None:
         """
         return self.forecast_registries.get(model_name)
 
-    def log_forecast_trees(self, timewindows: list) -> None:
+    def log_forecast_trees(self, time_windows: list) -> None:
         """
         Logs the forecasts for all models managed by this ExperimentRegistry.
         """
         log.debug("===================")
-        log.debug(f" Total Time Windows: {len(timewindows)}")
+        log.debug(f" Total Time Windows: {len(time_windows)}")
         for model_name, registry in self.forecast_registries.items():
             log.debug(f"  Model: {model_name}")
             registry.log_tree()

floatcsep/infrastructure/repositories.py

@@ -381,8 +381,8 @@ def catalog(self) -> CSEPCatalog:
             if isfile(self.cat_path):
                 return CSEPCatalog.load_json(self.cat_path)
             bounds = {
-                "start_time": min([item for sublist in self.timewindows for item in sublist]),
-                "end_time": max([item for sublist in self.timewindows for item in sublist]),
+                "start_time": min([item for sublist in self.time_windows for item in sublist]),
+                "end_time": max([item for sublist in self.time_windows for item in sublist]),
                 "min_magnitude": self.magnitudes.min(),
                 "max_depth": self.depths.max(),
             }

floatcsep/model.py

@@ -60,7 +60,7 @@ def __init__(
         self.__dict__.update(**kwargs)
 
     @abstractmethod
-    def stage(self, timewindows=None) -> None:
+    def stage(self, time_windows=None) -> None:
         """Prepares the stage for a model run."""
         pass
 
@@ -215,13 +215,13 @@ def __init__(self, name: str, model_path: str, forecast_unit=1, store_db=False,
             self.registry, model_class=self.__class__.__name__, **kwargs
         )
 
-    def stage(self, timewindows: Sequence[Sequence[datetime]] = None) -> None:
+    def stage(self, time_windows: Sequence[Sequence[datetime]] = None) -> None:
         """
         Acquire the forecast data if it is not in the file system. Sets the paths internally
         (or database pointers) to the forecast data.
 
         Args:
-            timewindows (list): time_windows that the forecast data represents.
+            time_windows (list): time_windows that the forecast data represents.
         """
 
         if self.force_stage or not self.registry.file_exists("path"):
@@ -231,7 +231,7 @@ def stage(self, timewindows: Sequence[Sequence[datetime]] = None) -> None:
         if self.store_db:
             self.init_db()
 
-        self.registry.build_tree(time_windows=timewindows, model_class=self.__class__.__name__)
+        self.registry.build_tree(time_windows=time_windows, model_class=self.__class__.__name__)
 
     def init_db(self, dbpath: str = "", force: bool = False) -> None:
         """
@@ -333,7 +333,7 @@ def __init__(
                 self.build, self.name, self.registry.abs(model_path)
             )
 
-    def stage(self, timewindows=None) -> None:
+    def stage(self, time_windows=None) -> None:
         """
         Core method to interface a model with the experiment.
 
@@ -351,7 +351,7 @@ def stage(self, timewindows=None) -> None:
             self.environment.create_environment(force=self.force_build)
 
         self.registry.build_tree(
-            time_windows=timewindows,
+            time_windows=time_windows,
             model_class=self.__class__.__name__,
             prefix=self.__dict__.get("prefix", self.name),
             args_file=self.__dict__.get("args_file", None),

floatcsep/postprocess/plot_handler.py

@@ -27,10 +27,10 @@ def plot_results(experiment: "Experiment") -> None:
 
     """
     log.info("Plotting evaluation results")
-    timewindows = timewindow2str(experiment.timewindows)
+    time_windows = timewindow2str(experiment.time_windows)
 
     for test in experiment.tests:
-        test.plot_results(timewindows, experiment.models, experiment.registry)
+        test.plot_results(time_windows, experiment.models, experiment.registry)
 
 
 def plot_forecasts(experiment: "Experiment") -> None:
@@ -76,9 +76,9 @@ def plot_forecasts(experiment: "Experiment") -> None:
 
     # Get the time windows to be plotted. Defaults to only the last time window.
     time_windows = (
-        timewindow2str(experiment.timewindows)
+        timewindow2str(experiment.time_windows)
         if plot_forecast_config.get("all_time_windows")
-        else [timewindow2str(experiment.timewindows[-1])]
+        else [timewindow2str(experiment.time_windows[-1])]
     )
 
     # Get the projection of the plots
@@ -177,7 +177,7 @@ def plot_catalogs(experiment: "Experiment") -> None:
 
     # If selected, plot the test catalogs for each of the time windows
     if plot_catalog_config.get("all_time_windows"):
-        for tw in experiment.timewindows:
+        for tw in experiment.time_windows:
             test_catalog = experiment.catalog_repo.get_test_cat(timewindow2str(tw))
 
             if test_catalog.get_number_of_events() != 0:

floatcsep/postprocess/reporting.py

@@ -35,7 +35,7 @@ def generate_report(experiment, timewindow=-1):
         custom_report(report_function, experiment)
         return
 
-    timewindow = experiment.timewindows[timewindow]
+    timewindow = experiment.time_windows[timewindow]
     timestr = timewindow2str(timewindow)
 
     log.info(f"Saving report into {experiment.registry.run_dir}")

floatcsep/utils/helpers.py

@@ -158,14 +158,14 @@ def read_time_cfg(time_config, **kwargs):
     if "offset" in time_config.keys():
         time_config["offset"] = parse_timedelta_string(time_config["offset"])
 
-    if not time_config.get("timewindows"):
+    if not time_config.get("time_windows"):
         if experiment_class == "ti":
-            time_config["timewindows"] = timewindows_ti(**time_config)
+            time_config["time_windows"] = time_windows_ti(**time_config)
         elif experiment_class == "td":
-            time_config["timewindows"] = timewindows_td(**time_config)
+            time_config["time_windows"] = time_windows_td(**time_config)
     else:
-        time_config["start_date"] = time_config["timewindows"][0][0]
-        time_config["end_date"] = time_config["timewindows"][-1][-1]
+        time_config["start_date"] = time_config["time_windows"][0][0]
+        time_config["end_date"] = time_config["time_windows"][-1][-1]
 
     return time_config
 
@@ -242,7 +242,7 @@ def timewindow2str(datetimes: Sequence) -> Union[str, list[str]]:
     single timewindow or a list of time windows.
 
     Args:
-        datetimes: A sequence (of sequences) of datetimes, representing a list of timewindows
+        datetimes: A sequence (of sequences) of datetimes, representing a list of time_windows
 
     Returns:
         A sequence of strings for each time window
@@ -279,7 +279,7 @@ def str2timewindow(
         return datetimes
 
 
-def timewindows_ti(
+def time_windows_ti(
     start_date=None, end_date=None, intervals=None, horizon=None, growth="incremental", **_
 ):
     """
@@ -336,7 +336,7 @@ def timewindows_ti(
         return [(timelimits[0], i) for i in timelimits[1:]]
 
 
-def timewindows_td(
+def time_windows_td(
     start_date=None, end_date=None, timeintervals=None, timehorizon=None, timeoffset=None, **_
 ):
     """

tests/qa/test_data.py renamed to tests/e2e/test_data.py

@@ -35,10 +35,10 @@ def setUp(self):
         )
 
     def test_time_independent_model_stage(self):
-        timewindows = [
+        time_windows = [
             [datetime(2023, 1, 1), datetime(2023, 1, 2)],
         ]
-        self.time_independent_model.stage(timewindows=timewindows)
+        self.time_independent_model.stage(time_windows=time_windows)
         print("a", self.time_independent_model.registry.as_dict())
         self.assertIn("2023-01-01_2023-01-02", self.time_independent_model.registry.forecasts)
 
@@ -50,10 +50,10 @@ def test_time_independent_model_get_forecast(self):
 
     def test_time_independent_model_get_forecast_real(self):
         tstring = "2023-01-01_2023-01-02"
-        timewindows = [
+        time_windows = [
             [datetime(2023, 1, 1), datetime(2023, 1, 2)],
         ]
-        self.time_independent_model.stage(timewindows=timewindows)
+        self.time_independent_model.stage(time_windows=time_windows)
         forecast = self.time_independent_model.get_forecast(tstring)
         self.assertIsInstance(forecast, GriddedForecast)
         self.assertAlmostEqual(forecast.data[0, 0], 0.002739726027357392)  # 1 / 365 days
@@ -63,12 +63,12 @@ def test_time_independent_model_get_forecast_real(self):
     def test_time_dependent_model_stage(self, mock_venv, mock_conda):
         mock_venv.return_value = None
         mock_conda.return_value = None
-        timewindows = [
+        time_windows = [
             [datetime(2020, 1, 1), datetime(2020, 1, 2)],
             [datetime(2020, 1, 2), datetime(2020, 1, 3)],
         ]
         tstrings = ["2020-01-01_2020-01-02", "2020-01-02_2020-01-03"]
-        self.time_dependent_model.stage(timewindows=timewindows)
+        self.time_dependent_model.stage(time_windows=time_windows)
 
         self.assertIn(tstrings[0], self.time_dependent_model.registry.forecasts)
         self.assertIn(tstrings[1], self.time_dependent_model.registry.forecasts)
@@ -78,11 +78,11 @@ def test_time_dependent_model_stage(self, mock_venv, mock_conda):
     def test_time_dependent_model_get_forecast(self, mock_venv, mock_conda):
         mock_venv.return_value = None
         mock_conda.return_value = None
-        timewindows = [
+        time_windows = [
             [datetime(2020, 1, 1), datetime(2020, 1, 2)],
             [datetime(2020, 1, 2), datetime(2020, 1, 3)],
         ]
-        self.time_dependent_model.stage(timewindows)
+        self.time_dependent_model.stage(time_windows)
         tstring = "2020-01-01_2020-01-02"
         forecast = self.time_dependent_model.get_forecast(tstring)
         self.assertIsNotNone(forecast)

tests/integration/test_model_infrastructure.py

@@ -41,8 +41,8 @@ def assertEqualExperiment(self, exp_a, exp_b):
         self.assertEqual(exp_a.registry.workdir, os.getcwd())
         self.assertEqual(exp_a.registry.workdir, exp_b.registry.workdir)
         self.assertEqual(exp_a.start_date, exp_b.start_date)
-        print(exp_a.timewindows, exp_b.timewindows)
-        self.assertEqual(exp_a.timewindows, exp_b.timewindows)
+        print(exp_a.time_windows, exp_b.time_windows)
+        self.assertEqual(exp_a.time_windows, exp_b.time_windows)
         self.assertEqual(exp_a.exp_class, exp_b.exp_class)
         self.assertEqual(exp_a.region, exp_b.region)
         numpy.testing.assert_equal(exp_a.magnitudes, exp_b.magnitudes)

tests/unit/test_experiment.py

@@ -224,7 +224,7 @@ def test_init(self):
     def test_stage(self, mk):
         self.model.force_stage = True  # Force staging to occur
 
-        self.model.stage(timewindows=["2020-01-01_2020-12-31"])
+        self.model.stage(time_windows=["2020-01-01_2020-12-31"])
 
         self.mock_get_source.assert_called_once_with(
             self.model.zenodo_id, self.model.giturl, branch=self.model.repo_hash

tests/unit/test_model.py

@@ -15,7 +15,7 @@ def test_plot_results(self, mock_timewindow2str, mock_savefig):
 
         plot_handler.plot_results(mock_experiment)
 
-        mock_timewindow2str.assert_called_once_with(mock_experiment.timewindows)
+        mock_timewindow2str.assert_called_once_with(mock_experiment.time_windows)
         mock_test.plot_results.assert_called_once_with(
             ["2021-01-01", "2021-12-31"], mock_experiment.models, mock_experiment.registry
         )

tests/unit/test_plot_handler.py

@@ -67,9 +67,9 @@ def test_file_exists(self, mock_exists):
     @patch("os.makedirs")
     @patch("os.listdir")
     def test_build_tree_time_independent(self, mock_listdir, mock_makedirs):
-        timewindows = [[datetime(2023, 1, 1), datetime(2023, 1, 2)]]
+        time_windows = [[datetime(2023, 1, 1), datetime(2023, 1, 2)]]
         self.registry_for_filebased_model.build_tree(
-            time_windows=timewindows, model_class="TimeIndependentModel"
+            time_windows=time_windows, model_class="TimeIndependentModel"
         )
         self.assertIn("2023-01-01_2023-01-02", self.registry_for_filebased_model.forecasts)
         # self.assertIn("2023-01-01_2023-01-02", self.registry_for_filebased_model.inventory)
@@ -78,12 +78,12 @@ def test_build_tree_time_independent(self, mock_listdir, mock_makedirs):
     @patch("os.listdir")
     def test_build_tree_time_dependent(self, mock_listdir, mock_makedirs):
         mock_listdir.return_value = ["forecast_1.csv"]
-        timewindows = [
+        time_windows = [
             [datetime(2023, 1, 1), datetime(2023, 1, 2)],
             [datetime(2023, 1, 2), datetime(2023, 1, 3)],
         ]
         self.registry_for_folderbased_model.build_tree(
-            time_windows=timewindows, model_class="TimeDependentModel", prefix="forecast"
+            time_windows=time_windows, model_class="TimeDependentModel", prefix="forecast"
         )
         self.assertIn("2023-01-01_2023-01-02", self.registry_for_folderbased_model.forecasts)
         # self.assertTrue(self.registry_for_folderbased_model.inventory["2023-01-01_2023-01-02"])