flood-adapt 0.3.2__py3-none-any.whl → 0.3.4__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/objects/forcing/__init__.py

@@ -0,0 +1,92 @@
+from flood_adapt.objects.forcing.discharge import (
+    DischargeConstant,
+    DischargeCSV,
+    DischargeSynthetic,
+)
+from flood_adapt.objects.forcing.forcing import ForcingSource, ForcingType, IForcing
+from flood_adapt.objects.forcing.meteo_handler import MeteoHandler
+from flood_adapt.objects.forcing.rainfall import (
+    RainfallConstant,
+    RainfallCSV,
+    RainfallMeteo,
+    RainfallNetCDF,
+    RainfallSynthetic,
+    RainfallTrack,
+)
+from flood_adapt.objects.forcing.tide_gauge import TideGauge, TideGaugeSource
+from flood_adapt.objects.forcing.time_frame import TimeFrame
+from flood_adapt.objects.forcing.timeseries import (
+    BlockTimeseries,
+    CSVTimeseries,
+    GaussianTimeseries,
+    ScsTimeseries,
+    Scstype,
+    ShapeType,
+    SyntheticTimeseries,
+    TimeseriesFactory,
+    TriangleTimeseries,
+)
+from flood_adapt.objects.forcing.waterlevels import (
+    SurgeModel,
+    TideModel,
+    WaterlevelCSV,
+    WaterlevelGauged,
+    WaterlevelModel,
+    WaterlevelSynthetic,
+)
+from flood_adapt.objects.forcing.wind import (
+    WindConstant,
+    WindCSV,
+    WindMeteo,
+    WindNetCDF,
+    WindSynthetic,
+    WindTrack,
+)
+
+__all__ = [
+    # Forcing
+    "IForcing",
+    "ForcingSource",
+    "ForcingType",
+    # Timeseries
+    "ShapeType",
+    "Scstype",
+    "CSVTimeseries",
+    "TimeseriesFactory",
+    "SyntheticTimeseries",
+    "BlockTimeseries",
+    "ScsTimeseries",
+    "GaussianTimeseries",
+    "TriangleTimeseries",
+    # TimeFrame
+    "TimeFrame",
+    # Discharge
+    "DischargeConstant",
+    "DischargeCSV",
+    "DischargeSynthetic",
+    # Waterlevels
+    "WaterlevelCSV",
+    "WaterlevelGauged",
+    "WaterlevelModel",
+    "WaterlevelSynthetic",
+    "TideModel",
+    "SurgeModel",
+    "TideGauge",
+    "TideGaugeSource",
+    # Rainfall
+    "RainfallConstant",
+    "RainfallCSV",
+    "RainfallSynthetic",
+    "RainfallMeteo",
+    "RainfallNetCDF",
+    "RainfallTrack",
+    # Wind
+    "WindConstant",
+    "WindCSV",
+    "WindSynthetic",
+    "WindMeteo",
+    "WindNetCDF",
+    "WindTrack",
+    # Other
+    "MeteoHandler",
+]

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)