flood-adapt 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

flood_adapt/flood_adapt.py

@@ -38,6 +38,7 @@ from flood_adapt.objects.projections.projections import Projection
 from flood_adapt.objects.scenarios.scenarios import Scenario
 from flood_adapt.objects.strategies.strategies import Strategy
 from flood_adapt.workflows.impacts_integrator import Impacts
+from flood_adapt.workflows.scenario_runner import ScenarioRunner
 
 
 class FloodAdapt:
@@ -68,7 +69,7 @@ class FloodAdapt:
             Includes keys: 'name', 'description', 'path', 'last_modification_date', 'objects'
             Each value is a list of the corresponding attribute for each measure.
         """
-        return self.database.measures.list_objects()
+        return self.database.measures.summarize_objects()
 
     def get_measure(self, name: str) -> Measure:
         """
@@ -208,7 +209,7 @@ class FloodAdapt:
             Includes keys: 'name', 'description', 'path', 'last_modification_date', 'objects'
             Each value is a list of the corresponding attribute for each strategy.
         """
-        return self.database.strategies.list_objects()
+        return self.database.strategies.summarize_objects()
 
     def get_strategy(self, name: str) -> Strategy:
         """
@@ -310,7 +311,7 @@ class FloodAdapt:
             Includes keys: 'name', 'description', 'path', 'last_modification_date', 'objects'
             Each value is a list of the corresponding attribute for each benefit.
         """
-        return self.database.events.list_objects()
+        return self.database.events.summarize_objects()
 
     def get_event(self, name: str) -> Event | EventSet:
         """Get an event from the database by name.
@@ -476,7 +477,7 @@ class FloodAdapt:
             Includes keys: 'name', 'description', 'path', 'last_modification_date', 'objects'
             Each value is a list of the corresponding attribute for each projection.
         """
-        return self.database.projections.list_objects()
+        return self.database.projections.summarize_objects()
 
     def get_projection(self, name: str) -> Projection:
         """Get a projection from the database by name.
@@ -633,7 +634,7 @@ class FloodAdapt:
             Includes keys: 'name', 'description', 'path', 'last_modification_date', 'objects'.
             Each value is a list of the corresponding attribute for each scenario.
         """
-        return self.database.scenarios.list_objects()
+        return self.database.scenarios.summarize_objects()
 
     def get_scenario(self, name: str) -> Scenario:
         """Get a scenario from the database by name.
@@ -726,20 +727,26 @@ class FloodAdapt:
         """
         self.database.scenarios.delete(name)
 
-    def run_scenario(self, name: Union[str, list[str]]) -> None:
-        """Run a scenario.
+    def run_scenario(self, scenario_name: Union[str, list[str]]) -> None:
+        """Run a scenario hazard and impacts.
 
         Parameters
         ----------
-        name : Union[str, list[str]]
-            The name(s) of the scenario to run.
+        scenario_name : Union[str, list[str]]
+            name(s) of the scenarios to run.
 
         Raises
         ------
-        ValueError
-            If the scenario does not exist.
+        RuntimeError
+            If an error occurs while running one of the scenarios
         """
-        self.database.run_scenario(name)
+        if not isinstance(scenario_name, list):
+            scenario_name = [scenario_name]
+
+        for scn in scenario_name:
+            scenario = self.get_scenario(scn)
+            runner = ScenarioRunner(self.database, scenario=scenario)
+            runner.run()
 
     # Outputs
     def get_completed_scenarios(
@@ -1088,7 +1095,7 @@ class FloodAdapt:
             Each value is a list of the corresponding attribute for each benefit.
         """
         # sorting and filtering either with PyQt table or in the API
-        return self.database.benefits.list_objects()
+        return self.database.benefits.summarize_objects()
 
     def get_benefit(self, name: str) -> Benefit:
         """Get a benefit from the database by name.

flood_adapt/workflows/benefit_runner.py

@@ -117,7 +117,10 @@ class BenefitRunner:
                 scenarios_calc[scenario]["strategy"] = self.benefit.strategy
 
         # Get the available scenarios
-        scenarios_avail = self.database.scenarios.list_objects()["objects"]
+        scenarios_avail = [
+            self.database.scenarios.get(scn)
+            for scn in self.database.scenarios.summarize_objects()["name"]
+        ]
 
         # Check if any of the needed scenarios are already there
         for scenario in scenarios_calc.keys():

flood_adapt/workflows/scenario_runner.py

@@ -30,16 +30,17 @@ class ScenarioRunner:
             scenario=self._scenario,
         )
 
-    def run(self, scenario: Scenario) -> None:
+    def run(self) -> None:
         """Run hazard and impact models for the scenario."""
-        self._load_objects(scenario)
+        self._database.has_run_hazard(self._scenario.name)
+        self._load_objects(self._scenario)
         self.results_path.mkdir(parents=True, exist_ok=True)
 
         # Initiate the logger for all the integrator scripts.
-        log_file = self.results_path.joinpath(f"logfile_{scenario.name}.log")
+        log_file = self.results_path.joinpath(f"logfile_{self._scenario.name}.log")
         with FloodAdaptLogging.to_file(file_path=log_file):
             self.logger.info(f"FloodAdapt version `{__version__}`")
-            self.logger.info(f"Started evaluation of `{scenario.name}`")
+            self.logger.info(f"Started evaluation of `{self._scenario.name}`")
 
             hazard_models = [
                 self._database.static.get_overland_sfincs_model(),
@@ -49,17 +50,17 @@ class ScenarioRunner:
                     hazard.run(self._scenario)
                 else:
                     self.logger.info(
-                        f"Hazard for scenario '{scenario.name}' has already been run."
+                        f"Hazard for scenario '{self._scenario.name}' has already been run."
                     )
 
             if not self.impacts.has_run:
                 self.impacts.run()
             else:
                 self.logger.info(
-                    f"Impacts for scenario `{scenario.name}` has already been run."
+                    f"Impacts for scenario `{self._scenario.name}` has already been run."
                 )
 
-            self.logger.info(f"Finished evaluation of `{scenario.name}`")
+            self.logger.info(f"Finished evaluation of `{self._scenario.name}`")
 
         # write finished file to indicate that the scenario has been run
         write_finished_file(self.results_path)