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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flood-adapt
-Version: 0.3.8
+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.8 → 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.8 → 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.8"
+__version__ = "0.3.9"
 
 from flood_adapt import adapter, dbs_classes, objects
 from flood_adapt.config.config import Settings

{flood_adapt-0.3.8 → 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.8 → flood_adapt-0.3.9}/flood_adapt/adapter/sfincs_adapter.py

@@ -200,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,
@@ -1840,7 +1840,9 @@ class SfincsAdapter(IHazardAdapter):
             waterlevel = df_gauge.iloc[:, 0] + gauge_reference_height
 
             # If data is available, add to plot
-            fig.add_trace(px.line(waterlevel, color="#ea6404"))
+            fig.add_trace(
+                px.line(waterlevel, color_discrete_sequence=["#ea6404"]).data[0]
+            )
             fig["data"][0]["name"] = "model"
             fig["data"][1]["name"] = "measurement"
             fig.update_layout(showlegend=True)

{flood_adapt-0.3.8 → 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.8 → flood_adapt-0.3.9}/flood_adapt/database_builder/database_builder.py

@@ -1280,9 +1280,9 @@ class DatabaseBuilder:
             relative_to_year=self.config.slr_scenarios.relative_to_year,
         )
 
-    def create_observation_points(self) -> list[ObsPointModel]:
+    def create_observation_points(self) -> Union[list[ObsPointModel], None]:
         if self.config.obs_point is None:
-            return []
+            return None
 
         self.logger.info("Observation points were provided in the config file.")
         return self.config.obs_point

{flood_adapt-0.3.8 → flood_adapt-0.3.9}/flood_adapt/dbs_classes/database.py

@@ -335,7 +335,7 @@ class Database(IDatabase):
         benefit : Benefit
         """
         runner = BenefitRunner(self, benefit=benefit)
-        return runner.check_scenarios()
+        return runner.scenarios
 
     def create_benefit_scenarios(self, benefit: Benefit) -> None:
         """Create any scenarios that are needed for the (cost-)benefit assessment and are not there already.
@@ -345,7 +345,6 @@ class Database(IDatabase):
         benefit : Benefit
         """
         runner = BenefitRunner(self, benefit=benefit)
-        runner.check_scenarios()
 
         # Iterate through the scenarios needed and create them if not existing
         for index, row in runner.scenarios.iterrows():
@@ -368,9 +367,6 @@ class Database(IDatabase):
                         raise e
                     # otherwise, if it already exists and we dont need to save it, we can just continue
 
-        # Update the scenarios check
-        runner.check_scenarios()
-
     def run_benefit(self, benefit_name: Union[str, list[str]]) -> None:
         """Run a (cost-)benefit analysis.
 

{flood_adapt-0.3.8 → flood_adapt-0.3.9}/flood_adapt/dbs_classes/dbs_scenario.py

@@ -78,7 +78,7 @@ class DbsScenario(DbsTemplate[Scenario]):
         used_in_benefit = []
         for benefit in benefits:
             runner = BenefitRunner(database=self._database, benefit=benefit)
-            scenarios = runner.check_scenarios()["scenario created"].to_list()
+            scenarios = runner.scenarios["scenario created"].to_list()
             for scenario in scenarios:
                 if name == scenario:
                     used_in_benefit.append(benefit.name)

{flood_adapt-0.3.8 → flood_adapt-0.3.9}/flood_adapt/dbs_classes/dbs_static.py

@@ -253,7 +253,7 @@ class DbsStatic(IDbsStatic):
         with FiatAdapter(
             model_root=template_path,
             config=self._database.site.fiat.config,
-            exe_path=Settings().fiat_path,
+            exe_path=Settings().fiat_bin_path,
             delete_crashed_runs=Settings().delete_crashed_runs,
             config_base_path=self._database.static_path,
         ) as fm: