flood-adapt 0.3.7__tar.gz → 0.3.9__tar.gz

{flood_adapt-0.3.7 → flood_adapt-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flood-adapt
-Version: 0.3.7
+Version: 0.3.9
 Summary: A software package support system which can be used to assess the benefits and costs of flood resilience measures
 Author-email: Gundula Winter <Gundula.Winter@deltares.nl>, Panos Athanasiou <Panos.Athanasiou@deltares.nl>, Frederique de Groen <Frederique.deGroen@deltares.nl>, Tim de Wilde <Tim.deWilde@deltares.nl>, Julian Hofer <Julian.Hofer@deltares.nl>, Daley Adrichem <Daley.Adrichem@deltares.nl>, Luuk Blom <Luuk.Blom@deltares.nl>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -728,6 +728,8 @@ Requires-Dist: sphinx-rtd-theme<4.0,>=3.0; extra == "docs"
 Requires-Dist: regex<2025.0,>=2024.11; extra == "docs"
 Requires-Dist: minio<8,>=7.2.15; extra == "docs"
 Requires-Dist: python-dotenv<2.0,>=1.0; extra == "docs"
+Requires-Dist: folium<1.0,>=0.19.0; extra == "docs"
+Requires-Dist: mapclassify<3.0,>=2.8.0; extra == "docs"
 Provides-Extra: all
 Requires-Dist: flood-adapt[build,dev,docs]; extra == "all"
 
@@ -773,7 +775,7 @@ FloodAdapt uses a database to store, handle and organize input files, output fil
 To initialize FloodAdapt and configure the database, add the following lines to the top of your script / initialize function to validate and set the environment variables:
 ```python
 from pathlib import Path
-from flood_adapt.misc.config import Settings
+from flood_adapt import Settings
 
 # Usually ends in `Database` and can contain multiple sites
 root = Path("path/to/your/database/root")
@@ -781,14 +783,17 @@ root = Path("path/to/your/database/root")
 # Specifies which site to use
 name = "database_name"
 
-# Contains the model kernels to run that perform the calculations
-system_folder = Path("path/to/your/system/folder")
+# Define the paths to the model kernel binaries
+sfincs_bin = Path("path/to/your/sfincs/bin.exe")
+fiat_bin = Path("path/to/your/fiat/bin.exe")
 
 # Validate and set environment variables
 Settings(
     DATABASE_ROOT=root,
     DATABASE_NAME=name,
-    SYSTEM_FOLDER=system_folder,
+    SFINCS_BIN_PATH=sfincs_bin,
+    FIAT_BIN_PATH=fiat_path,
+    VALIDATE_BINARIES=True,
 )
 ```
 

{flood_adapt-0.3.7 → flood_adapt-0.3.9}/README.md

@@ -40,7 +40,7 @@ FloodAdapt uses a database to store, handle and organize input files, output fil
 To initialize FloodAdapt and configure the database, add the following lines to the top of your script / initialize function to validate and set the environment variables:
 ```python
 from pathlib import Path
-from flood_adapt.misc.config import Settings
+from flood_adapt import Settings
 
 # Usually ends in `Database` and can contain multiple sites
 root = Path("path/to/your/database/root")
@@ -48,14 +48,17 @@ root = Path("path/to/your/database/root")
 # Specifies which site to use
 name = "database_name"
 
-# Contains the model kernels to run that perform the calculations
-system_folder = Path("path/to/your/system/folder")
+# Define the paths to the model kernel binaries
+sfincs_bin = Path("path/to/your/sfincs/bin.exe")
+fiat_bin = Path("path/to/your/fiat/bin.exe")
 
 # Validate and set environment variables
 Settings(
     DATABASE_ROOT=root,
     DATABASE_NAME=name,
-    SYSTEM_FOLDER=system_folder,
+    SFINCS_BIN_PATH=sfincs_bin,
+    FIAT_BIN_PATH=fiat_path,
+    VALIDATE_BINARIES=True,
 )
 ```
 

{flood_adapt-0.3.7 → flood_adapt-0.3.9}/flood_adapt/__init__.py

@@ -1,5 +1,5 @@
 # has to be here at the start to avoid circular imports
-__version__ = "0.3.7"
+__version__ = "0.3.9"
 
 from flood_adapt import adapter, dbs_classes, objects
 from flood_adapt.config.config import Settings

{flood_adapt-0.3.7 → flood_adapt-0.3.9}/flood_adapt/adapter/fiat_adapter.py

@@ -85,7 +85,7 @@ class FiatAdapter(IImpactAdapter):
     # TODO deal with all the relative paths for the files used
     # TODO IImpactAdapter and general Adapter class should NOT use the database
 
-    _model: FiatModel  # hydroMT-FIAT model
+    _model: Optional[FiatModel] = None
     config: Optional[FiatConfigModel] = None
     exe_path: Optional[os.PathLike] = None
     fiat_columns: FiatColumns
@@ -106,20 +106,27 @@ class FiatAdapter(IImpactAdapter):
         self.config_base_path = config_base_path
         self.exe_path = exe_path
         self.delete_crashed_runs = delete_crashed_runs
-        self._model = FiatModel(root=str(model_root.resolve()), mode="r")
-        self._model.read()
+        self._model_root = str(model_root.resolve())
         self.fiat_columns = _FIAT_COLUMNS
         self.impact_columns = _IMPACT_COLUMNS  # columns of FA impact output
 
+    @property
+    def model(self) -> FiatModel:
+        """Lazily load and cache the FiatModel."""
+        if self._model is None:
+            self._model = FiatModel(root=self._model_root, mode="r")
+            self._model.read()
+        return self._model
+
     @property
     def model_root(self):
-        return Path(self._model.root)
+        return Path(self.model.root)
 
     @property
     def damage_types(self):
         """Get the damage types that are present in the exposure."""
         types = []
-        for col in self._model.exposure.exposure_db.columns:
+        for col in self.model.exposure.exposure_db.columns:
             if matches_pattern(col, self.fiat_columns.damage_function):
                 name = extract_variables(col, self.fiat_columns.damage_function)["name"]
                 types.append(name)
@@ -127,9 +134,9 @@ class FiatAdapter(IImpactAdapter):
 
     def read(self, path: Path) -> None:
         """Read the fiat model from the current model root."""
-        if Path(self._model.root).resolve() != Path(path).resolve():
-            self._model.set_root(root=str(path), mode="r")
-        self._model.read()
+        if Path(self.model.root).resolve() != Path(path).resolve():
+            self.model.set_root(root=str(path), mode="r")
+        self.model.read()
 
     def write(self, path_out: Union[str, os.PathLike], overwrite: bool = True) -> None:
         """Write the fiat model configuration to a directory."""
@@ -141,8 +148,8 @@ class FiatAdapter(IImpactAdapter):
 
         write_mode = "w+" if overwrite else "w"
         with cd(path_out):
-            self._model.set_root(root=str(path_out), mode=write_mode)
-            self._model.write()
+            self.model.set_root(root=str(path_out), mode=write_mode)
+            self.model.write()
 
     def close_files(self):
         """Close all open files and clean up file handles."""
@@ -206,7 +213,7 @@ class FiatAdapter(IImpactAdapter):
             True if fiat has run, False if something went wrong
         """
         log_file = self.model_root.joinpath(
-            self._model.config["output"]["path"], "fiat.log"
+            self.model.config["output"]["path"], "fiat.log"
         )
         if not log_file.exists():
             return False
@@ -365,13 +372,13 @@ class FiatAdapter(IImpactAdapter):
                 The contents of the output CSV file.
         """
         # Get output path
-        outputs_path = self.model_root.joinpath(self._model.config["output"]["path"])
+        outputs_path = self.model_root.joinpath(self.model.config["output"]["path"])
 
         # Get all csvs and concatenate them in a single table
         csv_outputs_df = []
-        for output_csv in self._model.config["output"]["csv"]:
+        for output_csv in self.model.config["output"]["csv"]:
             csv_path = outputs_path.joinpath(
-                self._model.config["output"]["csv"][output_csv]
+                self.model.config["output"]["csv"][output_csv]
             )
             output_csv_df = pd.read_csv(csv_path)
             csv_outputs_df.append(output_csv_df)
@@ -700,9 +707,9 @@ class FiatAdapter(IImpactAdapter):
         self.logger.info(f"Setting hazard to the {map_type} map {map_fn}")
         # Add the floodmap data to a data catalog with the unit conversion
         wl_current_units = us.UnitfulLength(value=1.0, units=units)
-        conversion_factor = wl_current_units.convert(self._model.exposure.unit)
+        conversion_factor = wl_current_units.convert(self.model.exposure.unit)
 
-        self._model.setup_hazard(
+        self.model.setup_hazard(
             map_fn=map_fn,
             map_type=map_type,
             rp=None,
@@ -737,29 +744,29 @@ class FiatAdapter(IImpactAdapter):
         # Get columns that include max damage
         damage_cols = [
             c
-            for c in self._model.exposure.exposure_db.columns
+            for c in self.model.exposure.exposure_db.columns
             if matches_pattern(c, self.fiat_columns.max_potential_damage)
         ]
 
         # Get objects that are buildings (using site info)
-        buildings_rows = ~self._model.exposure.exposure_db[
+        buildings_rows = ~self.model.exposure.exposure_db[
             self.fiat_columns.primary_object_type
         ].isin(self.config.non_building_names)
 
         # If ids are given use that as an additional filter
         if ids:
-            buildings_rows = buildings_rows & self._model.exposure.exposure_db[
+            buildings_rows = buildings_rows & self.model.exposure.exposure_db[
                 self.fiat_columns.object_id
             ].isin(ids)
 
         # Update columns using economic growth value
-        updated_max_pot_damage = self._model.exposure.exposure_db.copy()
+        updated_max_pot_damage = self.model.exposure.exposure_db.copy()
         updated_max_pot_damage.loc[buildings_rows, damage_cols] *= (
             1.0 + economic_growth / 100.0
         )
 
         # update fiat model
-        self._model.exposure.update_max_potential_damage(
+        self.model.exposure.update_max_potential_damage(
             updated_max_potential_damages=updated_max_pot_damage
         )
 
@@ -784,29 +791,29 @@ class FiatAdapter(IImpactAdapter):
         # Get columns that include max damage
         damage_cols = [
             c
-            for c in self._model.exposure.exposure_db.columns
+            for c in self.model.exposure.exposure_db.columns
             if matches_pattern(c, self.fiat_columns.max_potential_damage)
         ]
 
         # Get objects that are buildings (using site info)
-        buildings_rows = ~self._model.exposure.exposure_db[
+        buildings_rows = ~self.model.exposure.exposure_db[
             self.fiat_columns.primary_object_type
         ].isin(self.config.non_building_names)
 
         # If ids are given use that as an additional filter
         if ids:
-            buildings_rows = buildings_rows & self._model.exposure.exposure_db[
+            buildings_rows = buildings_rows & self.model.exposure.exposure_db[
                 self.fiat_columns.object_id
             ].isin(ids)
 
         # Update columns using economic growth value
-        updated_max_pot_damage = self._model.exposure.exposure_db.copy()
+        updated_max_pot_damage = self.model.exposure.exposure_db.copy()
         updated_max_pot_damage.loc[buildings_rows, damage_cols] *= (
             1.0 + population_growth / 100.0
         )
 
         # update fiat model
-        self._model.exposure.update_max_potential_damage(
+        self.model.exposure.update_max_potential_damage(
             updated_max_potential_damages=updated_max_pot_damage
         )
 
@@ -841,7 +848,7 @@ class FiatAdapter(IImpactAdapter):
             If `elevation_type` is not 'floodmap' or 'datum'.
         """
         self.logger.info(
-            f"Applying population growth of {population_growth} %, by creating a new development area using the geometries from {area_path} and a ground floor height of {ground_floor_height} {self._model.exposure.unit} above '{elevation_type}'."
+            f"Applying population growth of {population_growth} %, by creating a new development area using the geometries from {area_path} and a ground floor height of {ground_floor_height} {self.model.exposure.unit} above '{elevation_type}'."
         )
         # Get reference type to align with hydromt
         if elevation_type == "floodmap":
@@ -870,12 +877,12 @@ class FiatAdapter(IImpactAdapter):
         ]
         new_dev_geom_name = Path(self.config.new_development_file_name).stem
         # Use hydromt function
-        self._model.exposure.setup_new_composite_areas(
+        self.model.exposure.setup_new_composite_areas(
             percent_growth=population_growth,
             geom_file=Path(area_path),
             ground_floor_height=ground_floor_height,
             damage_types=self.damage_types,
-            vulnerability=self._model.vulnerability,
+            vulnerability=self.model.vulnerability,
             ground_elevation=ground_elevation,
             aggregation_area_fn=aggregation_areas,
             attribute_names=attribute_names,
@@ -944,7 +951,7 @@ class FiatAdapter(IImpactAdapter):
                 path_ref = self.config_base_path.joinpath(self.config.bfe.geom)
                 height_reference = "geom"
             # Use hydromt function
-            self._model.exposure.raise_ground_floor_height(
+            self.model.exposure.raise_ground_floor_height(
                 raise_by=elevate.elevation.value,
                 objectids=objectids,
                 height_reference=height_reference,
@@ -954,7 +961,7 @@ class FiatAdapter(IImpactAdapter):
 
         elif elevate.elevation.type == "datum":
             # Use hydromt function
-            self._model.exposure.raise_ground_floor_height(
+            self.model.exposure.raise_ground_floor_height(
                 raise_by=elevate.elevation.value,
                 objectids=objectids,
                 height_reference="datum",
@@ -979,30 +986,28 @@ class FiatAdapter(IImpactAdapter):
         # Get columns that include max damage
         damage_cols = [
             c
-            for c in self._model.exposure.exposure_db.columns
+            for c in self.model.exposure.exposure_db.columns
             if matches_pattern(c, self.fiat_columns.max_potential_damage)
         ]
 
         # Get objects that are buildings (using site info)
-        buildings_rows = ~self._model.exposure.exposure_db[
+        buildings_rows = ~self.model.exposure.exposure_db[
             self.fiat_columns.primary_object_type
         ].isin(self.config.non_building_names)
 
         # Get rows that are affected
         objectids = self.get_object_ids(buyout)
         rows = (
-            self._model.exposure.exposure_db[self.fiat_columns.object_id].isin(
-                objectids
-            )
+            self.model.exposure.exposure_db[self.fiat_columns.object_id].isin(objectids)
             & buildings_rows
         )
 
         # Update columns
-        updated_max_pot_damage = self._model.exposure.exposure_db.copy()
+        updated_max_pot_damage = self.model.exposure.exposure_db.copy()
         updated_max_pot_damage.loc[rows, damage_cols] *= 0
 
         # update fiat model
-        self._model.exposure.update_max_potential_damage(
+        self.model.exposure.update_max_potential_damage(
             updated_max_potential_damages=updated_max_pot_damage
         )
 
@@ -1023,11 +1028,11 @@ class FiatAdapter(IImpactAdapter):
         objectids = self.get_object_ids(floodproof)
 
         # Use hydromt function
-        self._model.exposure.truncate_damage_function(
+        self.model.exposure.truncate_damage_function(
             objectids=objectids,
             floodproof_to=floodproof.elevation.value,
             damage_function_types=self.damage_types,
-            vulnerability=self._model.vulnerability,
+            vulnerability=self.model.vulnerability,
         )
 
     # STATIC METHODS
@@ -1046,11 +1051,11 @@ class FiatAdapter(IImpactAdapter):
         ValueError
             If the FIAT model does not have an exposure database initialized.
         """
-        if self._model.exposure is None:
+        if self.model.exposure is None:
             raise ValueError(
                 "FIAT model does not have exposure, make sure your model has been initialized."
             )
-        gdf_0 = self._model.exposure.select_objects(
+        gdf_0 = self.model.exposure.select_objects(
             primary_object_type="ALL",
             non_building_names=self.config.non_building_names,
             return_gdf=True,
@@ -1081,7 +1086,7 @@ class FiatAdapter(IImpactAdapter):
         ValueError
             If no property types are found in the FIAT model.
         """
-        types = self._model.exposure.get_primary_object_type()
+        types = self.model.exposure.get_primary_object_type()
         if types is None:
             raise ValueError("No property types found in the FIAT model.")
         types.append("all")  # Add "all" type for using as identifier
@@ -1104,7 +1109,7 @@ class FiatAdapter(IImpactAdapter):
             A list of IDs for all buildings in the FIAT model.
         """
         # Get ids of existing buildings
-        ids = self._model.exposure.get_object_ids(
+        ids = self.model.exposure.get_object_ids(
             "all", non_building_names=self.config.non_building_names
         )
         return ids
@@ -1145,7 +1150,7 @@ class FiatAdapter(IImpactAdapter):
             polygon_file = None
 
         # use the hydromt-fiat method to the ids
-        ids = self._model.exposure.get_object_ids(
+        ids = self.model.exposure.get_object_ids(
             selection_type=measure.selection_type,
             property_type=measure.property_type,
             non_building_names=self.config.non_building_names,
@@ -1407,7 +1412,7 @@ class FiatAdapter(IImpactAdapter):
         self.logger.info("Calculating impacts at a building footprint scale")
 
         # Read the existing building points
-        buildings = self._model.exposure.select_objects(
+        buildings = self.model.exposure.select_objects(
             primary_object_type="ALL",
             non_building_names=self.config.non_building_names,
             return_gdf=True,

{flood_adapt-0.3.7 → flood_adapt-0.3.9}/flood_adapt/adapter/sfincs_adapter.py

@@ -12,7 +12,6 @@ import hydromt_sfincs.utils as utils
 import numpy as np
 import pandas as pd
 import plotly.express as px
-import plotly.graph_objects as go
 import pyproj
 import shapely
 import xarray as xr
@@ -201,7 +200,7 @@ class SfincsAdapter(IHazardAdapter):
         with cd(path):
             self.logger.info(f"Running SFINCS in {path}")
             process = subprocess.run(
-                str(Settings().sfincs_path),
+                str(Settings().sfincs_bin_path),
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
@@ -677,7 +676,8 @@ class SfincsAdapter(IHazardAdapter):
             )
 
             event = self.database.events.get(scenario.event)
-            self._add_tide_gauge_plot(fig, event, units=gui_units)
+            if self.settings.obs_point[ii].name == self.settings.tide_gauge.name:
+                self._add_tide_gauge_plot(fig, event, units=gui_units)
 
             # write html to results folder
             station_name = gdf.iloc[ii]["Name"]
@@ -686,26 +686,27 @@ class SfincsAdapter(IHazardAdapter):
 
     def add_obs_points(self):
         """Add observation points provided in the site toml to SFINCS model."""
-        if self.settings.obs_point is not None:
-            self.logger.info("Adding observation points to the overland flood model")
-
-            obs_points = self.settings.obs_point
-            names = []
-            lat = []
-            lon = []
-            for pt in obs_points:
-                names.append(pt.name)
-                lat.append(pt.lat)
-                lon.append(pt.lon)
+        if self.settings.obs_point is None:
+            return
+        self.logger.info("Adding observation points to the overland flood model")
 
-            # create GeoDataFrame from obs_points in site file
-            df = pd.DataFrame({"name": names})
-            gdf = gpd.GeoDataFrame(
-                df, geometry=gpd.points_from_xy(lon, lat), crs="EPSG:4326"
-            )
+        obs_points = self.settings.obs_point
+        names = []
+        lat = []
+        lon = []
+        for pt in obs_points:
+            names.append(pt.name)
+            lat.append(pt.lat)
+            lon.append(pt.lon)
+
+        # create GeoDataFrame from obs_points in site file
+        df = pd.DataFrame({"name": names})
+        gdf = gpd.GeoDataFrame(
+            df, geometry=gpd.points_from_xy(lon, lat), crs="EPSG:4326"
+        )
 
-            # Add locations to SFINCS file
-            self._model.setup_observation_points(locations=gdf, merge=False)
+        # Add locations to SFINCS file
+        self._model.setup_observation_points(locations=gdf, merge=False)
 
     def get_wl_df_from_offshore_his_results(self) -> pd.DataFrame:
         """Create a pd.Dataframe with waterlevels from the offshore model at the bnd locations of the overland model.
@@ -1840,11 +1841,7 @@ class SfincsAdapter(IHazardAdapter):
 
             # If data is available, add to plot
             fig.add_trace(
-                go.Scatter(
-                    x=pd.DatetimeIndex(df_gauge.index),
-                    y=waterlevel,
-                    line_color="#ea6404",
-                )
+                px.line(waterlevel, color_discrete_sequence=["#ea6404"]).data[0]
             )
             fig["data"][0]["name"] = "model"
             fig["data"][1]["name"] = "measurement"

{flood_adapt-0.3.7 → flood_adapt-0.3.9}/flood_adapt/config/config.py

@@ -1,6 +1,6 @@
 from os import environ, listdir
 from pathlib import Path
-from platform import system
+from typing import Optional
 
 import tomli
 import tomli_w
@@ -12,48 +12,6 @@ from pydantic import (
 )
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-DEFAULT_SYSTEM_FOLDER = Path(__file__).parents[1] / "system"
-DEFAULT_EXE_PATHS: dict[str, dict[str, Path]] = {
-    "windows": {
-        "sfincs": DEFAULT_SYSTEM_FOLDER / "win-64" / "sfincs" / "sfincs.exe",
-        "fiat": DEFAULT_SYSTEM_FOLDER / "win-64" / "fiat" / "fiat.exe",
-    },
-    "linux": {
-        "sfincs": DEFAULT_SYSTEM_FOLDER / "linux-64" / "sfincs" / "bin" / "sfincs",
-        "fiat": DEFAULT_SYSTEM_FOLDER / "linux-64" / "fiat" / "fiat",
-    },
-}
-
-
-def _default_exe_path(exe_name: str) -> Path:
-    """
-    Get the default path for the given executable name based on the system type.
-
-    Parameters
-    ----------
-    exe_name : str
-        The name of the executable (e.g., "sfincs", "fiat").
-
-    Returns
-    -------
-    Path
-        The default path to the executable.
-
-    Raises
-    ------
-    ValueError
-        If the system type is not recognized.
-    """
-    if system().lower() not in DEFAULT_EXE_PATHS:
-        raise ValueError(
-            f"System type '{system()}' is not recognized. Supported types are: {', '.join(DEFAULT_EXE_PATHS.keys())}."
-        )
-    if exe_name not in DEFAULT_EXE_PATHS[system().lower()]:
-        raise ValueError(
-            f"Executable name '{exe_name}' is not recognized. Supported names are: {', '.join(DEFAULT_EXE_PATHS[system().lower()].keys())}."
-        )
-    return DEFAULT_EXE_PATHS[system().lower()][exe_name]
-
 
 class Settings(BaseSettings):
     """
@@ -82,19 +40,19 @@ class Settings(BaseSettings):
     Attributes
     ----------
     database_name : str
-        The name of the database.
+        The name of the database. Alias: `DATABASE_NAME` (environment variable).
     database_root : Path
-        The root directory of the database.
+        The root directory of the database. Alias: `DATABASE_ROOT` (environment variable).
     delete_crashed_runs : bool
-        Whether to delete crashed/corrupted runs immediately after they are detected.
-    sfincs_path : Path
-        The path to the SFINCS binary.
-    fiat_path : Path
-        The path to the FIAT binary.
+        Whether to delete crashed/corrupted runs immediately after they are detected. Alias: `DELETE_CRASHED_RUNS` (environment variable).
     validate_allowed_forcings : bool
-        Whether to validate the forcing types and sources against the allowed forcings in the event model.
-    validate_bin_paths : bool
-        Whether to validate the existence of the paths to the SFINCS and FIAT binaries.
+        Whether to validate the forcing types and sources against the allowed forcings in the event model. Alias: `VALIDATE_ALLOWED_FORCINGS` (environment variable).
+    validate_binaries : bool
+        Whether to validate the existence of the paths to the SFINCS and FIAT binaries. Alias: `VALIDATE_BINARIES` (environment variable).
+    sfincs_bin_path : Path
+        The path to the SFINCS binary. Alias: `SFINCS_BIN_PATH` (environment variable).
+    fiat_bin_path : Path
+        The path to the FIAT binary. Alias: `FIAT_BIN_PATH` (environment variable).
 
     Properties
     ----------
@@ -133,22 +91,22 @@ class Settings(BaseSettings):
         description="Whether to validate the forcing types and sources against the allowed forcings in the event model.",
         exclude=True,
     )
-    validate_bin_paths: bool = Field(
+    validate_binaries: bool = Field(
         alias="VALIDATE_BINARIES",  # environment variable: VALIDATE_BINARIES
         default=False,
         description="Whether to validate the existence of the paths to the SFINCS and FIAT binaries.",
         exclude=True,
     )
 
-    sfincs_path: Path = Field(
-        default=_default_exe_path("sfincs"),
+    sfincs_bin_path: Optional[Path] = Field(
+        default=None,
         alias="SFINCS_BIN_PATH",  # environment variable: SFINCS_BIN_PATH
         description="The path of the sfincs binary.",
         exclude=True,
     )
 
-    fiat_path: Path = Field(
-        default=_default_exe_path("fiat"),
+    fiat_bin_path: Optional[Path] = Field(
+        default=None,
         alias="FIAT_BIN_PATH",  # environment variable: FIAT_BIN_PATH
         description="The path of the fiat binary.",
         exclude=True,
@@ -162,7 +120,7 @@ class Settings(BaseSettings):
     @model_validator(mode="after")
     def validate_settings(self):
         self._validate_database_path()
-        if self.validate_bin_paths:
+        if self.validate_binaries:
             self._validate_fiat_path()
             self._validate_sfincs_path()
         self._update_environment_variables()
@@ -171,21 +129,21 @@ class Settings(BaseSettings):
     def _update_environment_variables(self):
         environ["DATABASE_ROOT"] = str(self.database_root)
         environ["DATABASE_NAME"] = self.database_name
-        environ["SFINCS_BIN_PATH"] = str(self.sfincs_path)
-        environ["FIAT_BIN_PATH"] = str(self.fiat_path)
-        environ["SFINCS_PATH"] = str(self.sfincs_path)
-        environ["FIAT_PATH"] = str(self.fiat_path)
 
         if self.delete_crashed_runs:
             environ["DELETE_CRASHED_RUNS"] = str(self.delete_crashed_runs)
         else:
             environ.pop("DELETE_CRASHED_RUNS", None)
+
         if self.validate_allowed_forcings:
             environ["VALIDATE_ALLOWED_FORCINGS"] = str(self.validate_allowed_forcings)
         else:
             environ.pop("VALIDATE_ALLOWED_FORCINGS", None)
-        if self.validate_bin_paths:
-            environ["VALIDATE_BINARIES"] = str(self.validate_bin_paths)
+
+        if self.validate_binaries:
+            environ["VALIDATE_BINARIES"] = str(self.validate_binaries)
+            environ["SFINCS_BIN_PATH"] = str(self.sfincs_bin_path)
+            environ["FIAT_BIN_PATH"] = str(self.fiat_bin_path)
         else:
             environ.pop("VALIDATE_BINARIES", None)
 
@@ -224,13 +182,13 @@ class Settings(BaseSettings):
         return self
 
     def _validate_sfincs_path(self):
-        if not self.sfincs_path.exists():
-            raise ValueError(f"SFINCS binary {self.sfincs_path} does not exist.")
+        if not self.sfincs_bin_path.exists():
+            raise ValueError(f"SFINCS binary {self.sfincs_bin_path} does not exist.")
         return self
 
     def _validate_fiat_path(self):
-        if not self.fiat_path.exists():
-            raise ValueError(f"FIAT binary {self.fiat_path} does not exist.")
+        if not self.fiat_bin_path.exists():
+            raise ValueError(f"FIAT binary {self.fiat_bin_path} does not exist.")
         return self
 
     @field_serializer("database_root", "database_path")
@@ -284,7 +242,7 @@ class Settings(BaseSettings):
             tomli_w.dump(
                 self.model_dump(
                     by_alias=True,
-                    exclude={"sfincs_path", "fiat_path", "database_path"},
+                    exclude={"sfincs_bin_path", "fiat_bin_path", "database_path"},
                 ),
                 f,
             )

{flood_adapt-0.3.7 → flood_adapt-0.3.9}/flood_adapt/config/fiat.py

@@ -209,7 +209,7 @@ class FiatModel(BaseModel):
     config: FiatConfigModel
 
     benefits: Optional[BenefitsModel] = None
-    risk: Optional[RiskModel] = None
+    risk: Optional[RiskModel] = RiskModel()
 
     @staticmethod
     def read_toml(path: Path) -> "FiatModel":