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

flood_adapt/__init__.py

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

flood_adapt/adapter/fiat_adapter.py

@@ -319,9 +319,11 @@ class FiatAdapter(IImpactAdapter):
         fiat_log = path / "fiat.log"
         with cd(path):
             with FloodAdaptLogging.to_file(file_path=fiat_log):
+                FiatAdapter._ensure_correct_hash_spacing_in_csv(path)
+
                 self.logger.info(f"Running FIAT in {path}")
                 process = subprocess.run(
-                    f'"{exe_path.as_posix()}" run settings.toml',
+                    args=[Path(exe_path).resolve().as_posix(), "run", "settings.toml"],
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     text=True,
@@ -1500,3 +1502,35 @@ class FiatAdapter(IImpactAdapter):
         )
         # Save as geopackage
         roads.to_file(output_path, driver="GPKG")
+
+    @staticmethod
+    def _ensure_correct_hash_spacing_in_csv(
+        model_root: Path, hash_spacing: int = 1
+    ) -> None:
+        """
+        Ensure that the CSV file has the correct number of spaces between hashes.
+
+        When writing csv files, FIAT does not add spaces between the hashes and the line, which leads to errors on linux.
+
+
+        Parameters
+        ----------
+        file_path : Path
+            The path to the model root.
+        hash_spacing : int, optional
+            The number of spaces between hashes, by default 1.
+        """
+        for dirpath, _, filenames in os.walk(model_root):
+            for filename in filenames:
+                if not filename.lower().endswith(".csv"):
+                    continue
+                file_path = os.path.join(dirpath, filename)
+
+                with open(file_path, "r") as file:
+                    lines = file.readlines()
+
+                with open(file_path, "w") as file:
+                    for line in lines:
+                        if line.startswith("#"):
+                            line = "#" + " " * hash_spacing + line.lstrip("#")
+                        file.write(line)

flood_adapt/config/config.py

@@ -1,7 +1,6 @@
 from os import environ, listdir
 from pathlib import Path
 from platform import system
-from typing import ClassVar
 
 import tomli
 import tomli_w
@@ -13,6 +12,48 @@ 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):
     """
@@ -25,7 +66,7 @@ class Settings(BaseSettings):
 
     Usage
     -----
-    from flood_adapt.config import Settings
+    from flood_adapt import Settings
 
     One of the following:
 
@@ -36,7 +77,7 @@ class Settings(BaseSettings):
         `settings = Settings.read(toml_path: Path)`
 
     3) Load settings from keyword arguments, overwriting any environment variables:
-        `settings = Settings(DATABASE_ROOT="path/to/database", DATABASE_NAME="database_name", SYSTEM_FOLDER="path/to/system_folder")`
+        `settings = Settings(DATABASE_ROOT="path/to/database", DATABASE_NAME="database_name")`
 
     Attributes
     ----------
@@ -44,19 +85,21 @@ class Settings(BaseSettings):
         The name of the database.
     database_root : Path
         The root directory of the database.
-    system_folder : Path
-        The root directory of the system folder containing the kernels.
     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.
+    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.
 
     Properties
     ----------
     database_path : Path
         The full path to the database.
-    sfincs_path : Path
-        The path to the SFINCS binary.
-    fiat_path : Path
-        The path to the FIAT binary.
 
     Raises
     ------
@@ -64,12 +107,6 @@ class Settings(BaseSettings):
         If required settings are missing or invalid.
     """
 
-    SYSTEM_SUFFIXES: ClassVar[dict[str, str]] = {
-        "Windows": ".exe",
-        "Linux": "",
-        "Darwin": "",
-    }
-
     model_config = SettingsConfigDict(env_ignore_empty=True, validate_default=True)
 
     database_root: Path = Field(
@@ -83,33 +120,39 @@ class Settings(BaseSettings):
         default="",
         description="The name of the database site, should be a folder inside the database root. The site must contain an 'input' and 'static' folder.",
     )
-    system_folder: Path = Field(
-        alias="SYSTEM_FOLDER",  # environment variable: SYSTEM_FOLDER
-        default=Path(__file__).parents[1] / "system",
-        description="The path of the system folder containing the kernels that run the calculations. Default is to look for the system folder in `FloodAdapt/flood_adapt/system`",
-    )
+
     delete_crashed_runs: bool = Field(
         alias="DELETE_CRASHED_RUNS",  # environment variable: DELETE_CRASHED_RUNS
-        default=True,
+        default=False,
         description="Whether to delete the output of crashed/corrupted runs. Be careful when setting this to False, as it may lead to a broken database that cannot be read in anymore.",
         exclude=True,
     )
     validate_allowed_forcings: bool = Field(
         alias="VALIDATE_ALLOWED_FORCINGS",  # environment variable: VALIDATE_ALLOWED_FORCINGS
-        default=True,
+        default=False,
         description="Whether to validate the forcing types and sources against the allowed forcings in the event model.",
         exclude=True,
     )
+    validate_bin_paths: 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,
+    )
 
-    @computed_field
-    @property
-    def sfincs_path(self) -> Path:
-        return self.system_folder / "sfincs" / f"sfincs{Settings._system_extension()}"
+    sfincs_path: Path = Field(
+        default=_default_exe_path("sfincs"),
+        alias="SFINCS_BIN_PATH",  # environment variable: SFINCS_BIN_PATH
+        description="The path of the sfincs binary.",
+        exclude=True,
+    )
 
-    @computed_field
-    @property
-    def fiat_path(self) -> Path:
-        return self.system_folder / "fiat" / f"fiat{Settings._system_extension()}"
+    fiat_path: Path = Field(
+        default=_default_exe_path("fiat"),
+        alias="FIAT_BIN_PATH",  # environment variable: FIAT_BIN_PATH
+        description="The path of the fiat binary.",
+        exclude=True,
+    )
 
     @computed_field
     @property
@@ -119,18 +162,33 @@ class Settings(BaseSettings):
     @model_validator(mode="after")
     def validate_settings(self):
         self._validate_database_path()
-        self._validate_system_folder()
-        self._validate_fiat_path()
-        self._validate_sfincs_path()
+        if self.validate_bin_paths:
+            self._validate_fiat_path()
+            self._validate_sfincs_path()
         self._update_environment_variables()
         return self
 
     def _update_environment_variables(self):
         environ["DATABASE_ROOT"] = str(self.database_root)
         environ["DATABASE_NAME"] = self.database_name
-        environ["SYSTEM_FOLDER"] = str(self.system_folder)
-        environ["DELETE_CRASHED_RUNS"] = str(self.delete_crashed_runs)
-        environ["VALIDATE_ALLOWED_FORCINGS"] = str(self.validate_allowed_forcings)
+        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)
+        else:
+            environ.pop("VALIDATE_BINARIES", None)
+
         return self
 
     def _validate_database_path(self):
@@ -165,11 +223,6 @@ class Settings(BaseSettings):
 
         return self
 
-    def _validate_system_folder(self):
-        if not self.system_folder.is_dir():
-            raise ValueError(f"System folder {self.system_folder} does not exist.")
-        return self
-
     def _validate_sfincs_path(self):
         if not self.sfincs_path.exists():
             raise ValueError(f"SFINCS binary {self.sfincs_path} does not exist.")
@@ -180,18 +233,10 @@ class Settings(BaseSettings):
             raise ValueError(f"FIAT binary {self.fiat_path} does not exist.")
         return self
 
-    @field_serializer(
-        "database_root", "system_folder", "sfincs_path", "fiat_path", "database_path"
-    )
+    @field_serializer("database_root", "database_path")
     def serialize_path(self, path: Path) -> str:
         return str(path)
 
-    @staticmethod
-    def _system_extension() -> str:
-        if system() not in Settings.SYSTEM_SUFFIXES:
-            raise ValueError(f"Unsupported system {system()}")
-        return Settings.SYSTEM_SUFFIXES[system()]
-
     @staticmethod
     def read(toml_path: Path) -> "Settings":
         """

flood_adapt/config/gui.py

@@ -1,103 +1,210 @@
 from pathlib import Path
 from typing import Optional
 
-from pydantic import BaseModel, Field
-from tomli import load as load_toml
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+import tomli
+from pydantic import BaseModel, Field, model_validator
 
 from flood_adapt.config.fiat import DamageType
 from flood_adapt.objects.forcing import unit_system as us
 
 
-class MapboxLayersModel(BaseModel):
+class Layer(BaseModel):
+    """
+    Base class for layers in the GUI.
+
+    Attributes
+    ----------
+    bins : list[float]
+        The bins for the layer.
+    colors : list[str]
+        The colors for the layer.
+    """
+
+    bins: list[float]
+    colors: list[str]
+
+    @model_validator(mode="after")
+    def check_bins_and_colors(self) -> "Layer":
+        """Check that the bins and colors have the same length."""
+        if (len(self.bins) + 1) != len(self.colors):
+            raise ValueError(
+                f"Number of bins ({len(self.bins)}) must be one less than number of colors ({len(self.colors)})"
+            )
+        return self
+
+
+class FloodMapLayer(Layer):
+    zbmax: float
+    depth_min: float
+
+
+class AggregationDmgLayer(Layer):
+    damage_decimals: Optional[int] = 0
+
+
+class FootprintsDmgLayer(Layer):
+    type: DamageType = DamageType.absolute
+    damage_decimals: Optional[int] = 0
+    buildings_min_zoom_level: int = 13
+
+
+class BenefitsLayer(Layer):
+    threshold: Optional[float] = None
+
+
+class OutputLayers(BaseModel):
     """The configuration of the mapbox layers in the gui.
 
     Attributes
     ----------
-    buildings_min_zoom_level : int
-        The minimum zoom level for the buildings layer.
-    flood_map_depth_min : float
-        The minimum depth for the flood map layer.
-    flood_map_zbmax : float
-        The maximum depth for the flood map layer.
-    flood_map_bins : list[float]
-        The bins for the flood map layer.
-    flood_map_colors : list[str]
-        The colors for the flood map layer.
-    aggregation_dmg_bins : list[float]
-        The bins for the aggregation damage layer.
-    aggregation_dmg_colors : list[str]
-        The colors for the aggregation damage layer.
-    footprints_dmg_type : DamageType
-        The type of damage for the footprints layer.
-    footprints_dmg_bins : list[float]
-        The bins for the footprints layer.
-    footprints_dmg_colors : list[str]
-        The colors for the footprints layer.
-    svi_bins : Optional[list[float]]
-        The bins for the SVI layer.
-    svi_colors : Optional[list[str]]
-        The colors for the SVI layer.
-    benefits_bins : list[float]
-        The bins for the benefits layer.
-    benefits_colors : list[str]
-        The colors for the benefits layer.
-    benefits_threshold : Optional[float], default=None
-        The threshold for the benefits layer.
-    damage_decimals : Optional[int], default=0
-        The number of decimals for the damage layer.
+    floodmap : FloodMapLayer
+        The configuration of the floodmap layer.
+    aggregation_dmg : AggregationDmgLayer
+        The configuration of the aggregation damage layer.
+    footprints_dmg : FootprintsDmgLayer
+        The configuration of the footprints damage layer.
 
+    benefits : BenefitsLayer
+        The configuration of the benefits layer.
     """
 
-    buildings_min_zoom_level: int = 13
-    flood_map_depth_min: float
-    flood_map_zbmax: float
-    flood_map_bins: list[float]
-    flood_map_colors: list[str]
-    aggregation_dmg_bins: list[float]
-    aggregation_dmg_colors: list[str]
-    footprints_dmg_type: DamageType = DamageType.absolute
-    footprints_dmg_bins: list[float]
-    footprints_dmg_colors: list[str]
-    svi_bins: Optional[list[float]] = Field(default_factory=list)
-    svi_colors: Optional[list[str]] = Field(default_factory=list)
-    benefits_bins: list[float]
-    benefits_colors: list[str]
-    benefits_threshold: Optional[float] = None
-    damage_decimals: Optional[int] = 0
+    floodmap: FloodMapLayer
+    aggregation_dmg: AggregationDmgLayer
+    footprints_dmg: FootprintsDmgLayer
+
+    benefits: Optional[BenefitsLayer] = None
 
 
-class VisualizationLayersModel(BaseModel):
+class VisualizationLayer(Layer):
+    """The configuration of a layer to visualize in the gui.
+
+    name : str
+        The name of the layer to visualize.
+    long_name : str
+        The long name of the layer to visualize.
+    path : str
+        The path to the layer data to visualize.
+    field_name : str
+        The field names of the layer to visualize.
+    decimals : Optional[int]
+        The number of decimals to use for the layer to visualize. default is None.
+    """
+
+    name: str
+    long_name: str
+    path: str
+    field_name: str
+    decimals: Optional[int] = None
+
+
+_DEFAULT_BIN_NR = 4
+
+
+def interpolate_hex_colors(
+    start_hex="#FFFFFF", end_hex="#860000", number_bins=_DEFAULT_BIN_NR
+):
+    """
+    Interpolate between two hex colors and returns a list of number_bins hex color codes.
+
+    Parameters
+    ----------
+        start_hex : str
+            Starting color in hex format (e.g., "#FFFFFF").
+        end_hex : str
+            Ending color in hex format (e.g., "#000000").
+        number_bins : int
+            Number of colors to generate between the start and end colors.
+
+    Returns
+    -------
+        list[str]
+            List of hex color codes interpolated between the start and end colors.
+    """
+
+    def hex_to_rgb(hex_color):
+        hex_color = hex_color.lstrip("#")
+        return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
+
+    def rgb_to_hex(rgb_color):
+        return "#{:02X}{:02X}{:02X}".format(*rgb_color)
+
+    start_rgb = hex_to_rgb(start_hex)
+    end_rgb = hex_to_rgb(end_hex)
+
+    interpolated_colors = []
+    for i in range(number_bins):
+        ratio = i / (number_bins - 1) if number_bins > 1 else 0
+        interpolated_rgb = tuple(
+            int(start + (end - start) * ratio) for start, end in zip(start_rgb, end_rgb)
+        )
+        interpolated_colors.append(rgb_to_hex(interpolated_rgb))
+
+    return interpolated_colors
+
+
+class VisualizationLayers(BaseModel):
     """The configuration of the layers you might want to visualize in the gui.
 
     Attributes
     ----------
-    default_bin_number : int
-        The default number of bins for the visualization layers.
-    default_colors : list[str]
-        The default colors for the visualization layers.
-    layer_names : list[str]
-        The names of the layers to visualize.
-    layer_long_names : list[str]
-        The long names of the layers to visualize.
-    layer_paths : list[str]
-        The paths to the layers to visualize.
-    field_names : list[str]
-        The field names of the layers to visualize.
-    bins : Optional[list[list[float]]]
-        The bins for the layers to visualize.
-    colors : Optional[list[list[str]]]
-        The colors for the layers to visualize.
+    default : Layer
+        The default layer settings the visualization layers.
+    layers : list[VisualizationLayer]
+        The layers to visualize.
     """
 
-    # TODO add check for default_bin_number and default_colors to have the same length
-    default_bin_number: int
-    default_colors: list[str]
-    layer_names: list[str] = Field(default_factory=list)
-    layer_long_names: list[str] = Field(default_factory=list)
-    layer_paths: list[str] = Field(default_factory=list)
-    field_names: list[str] = Field(default_factory=list)
-    bins: Optional[list[list[float]]] = Field(default_factory=list)
-    colors: Optional[list[list[str]]] = Field(default_factory=list)
+    layers: list[VisualizationLayer] = Field(default_factory=list)
+
+    def add_layer(
+        self,
+        name: str,
+        long_name: str,
+        path: str,
+        field_name: str,
+        database_path: Path,
+        decimals: Optional[int] = None,
+        bins: Optional[list[float]] = None,
+        colors: Optional[list[str]] = None,
+    ) -> None:
+        if not Path(path).is_absolute():
+            raise ValueError(f"Path {path} must be absolute.")
+
+        data = gpd.read_file(path)
+        if field_name not in data.columns:
+            raise ValueError(
+                f"Field name {field_name} not found in data. Available fields: {data.columns.tolist()}"
+            )
+
+        if bins is None:
+            _, _bins = pd.qcut(
+                data[field_name], _DEFAULT_BIN_NR, retbins=True, duplicates="drop"
+            )
+            bins = _bins.tolist()[1:-1]
+
+        if decimals is None:
+            non_zero_bins = [abs(b) for b in bins if b != 0]
+            min_non_zero = min(non_zero_bins) if non_zero_bins else 1
+            decimals = max(int(-np.floor(np.log10(min_non_zero))), 0)
+
+        if colors is None:
+            nr_bins = len(bins) + 1
+            colors = interpolate_hex_colors(number_bins=nr_bins)
+
+        relative_path = Path(path).relative_to(database_path / "static")
+        self.layers.append(
+            VisualizationLayer(
+                bins=bins,
+                colors=colors,
+                name=name,
+                long_name=long_name,
+                path=relative_path.as_posix(),
+                field_name=field_name,
+                decimals=decimals,
+            )
+        )
 
 
 class GuiUnitModel(BaseModel):
@@ -203,22 +310,22 @@ class GuiModel(BaseModel):
     ----------
     units : GuiUnitModel
         The unit system used in the GUI.
-    mapbox_layers : MapboxLayersModel
+    output_layers : OutputLayers
         The configuration of the mapbox layers in the GUI.
-    visualization_layers : VisualizationLayersModel
+    visualization_layers : VisualizationLayers
         The configuration of the visualization layers in the GUI.
     plotting : PlottingModel
         The configuration for creating hazard forcing plots.
     """
 
     units: GuiUnitModel
-    mapbox_layers: MapboxLayersModel
-    visualization_layers: VisualizationLayersModel
+    output_layers: OutputLayers
+    visualization_layers: VisualizationLayers
     plotting: PlottingModel
 
     @staticmethod
     def read_toml(path: Path) -> "GuiModel":
         with open(path, mode="rb") as fp:
-            toml_contents = load_toml(fp)
+            toml_contents = tomli.load(fp)
 
         return GuiModel(**toml_contents)