flood-adapt 1.1.3__tar.gz → 1.1.5__tar.gz

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flood-adapt
-Version: 1.1.3
+Version: 1.1.5
 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: ====================================================
@@ -712,14 +712,12 @@ Requires-Dist: cht-cyclones<2.0,>=1.0.3
 Requires-Dist: cht-meteo<1.0,>=0.3.1
 Requires-Dist: cht-observations<1.0,>=0.2.1
 Requires-Dist: cht-tide<1.0,>=0.1.1
-Requires-Dist: dask==2024.11.2
-Requires-Dist: numba_celltree==0.2.2
 Requires-Dist: fiat-toolbox<0.2.0,>=0.1.22
 Requires-Dist: fiona<2.0,>=1.0
 Requires-Dist: geojson<4.0,>=3.0
 Requires-Dist: geopandas<2.0,>=1.0
 Requires-Dist: hydromt-fiat<1.0,>=0.5.9
-Requires-Dist: hydromt-sfincs<2.0,>=1.2.0
+Requires-Dist: hydromt-sfincs<2.0,>=1.2.2
 Requires-Dist: numpy<2.0,>=1.0
 Requires-Dist: numpy-financial<2.0,>=1.0
 Requires-Dist: pandas<3.0,>=2.0

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/__init__.py

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

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/database_builder/__init__.py

@@ -1,11 +1,17 @@
+from flood_adapt.config import (
+    FloodModel,
+    SlrScenariosModel,
+)
 from flood_adapt.database_builder.database_builder import (
     Basins,
     ConfigModel,
     FootprintsOptions,
     GuiConfigModel,
+    ObsPointModel,
     SpatialJoinModel,
     SviConfigModel,
     TideGaugeConfigModel,
+    TideGaugeSource,
     UnitSystems,
     create_database,
 )
@@ -28,6 +34,7 @@ __all__ = [
     "SpatialJoinModel",
     "SviConfigModel",
     "TideGaugeConfigModel",
+    "TideGaugeSource",
     "UnitSystems",
     "create_database",
     "BuildingsInfographicModel",
@@ -37,4 +44,7 @@ __all__ = [
     "RiskInfographicModel",
     "RoadsInfographicModel",
     "ImpactCategoriesModel",
+    "FloodModel",
+    "SlrScenariosModel",
+    "ObsPointModel",
 ]

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/database_builder/database_builder.py

@@ -17,12 +17,14 @@ import numpy as np
 import pandas as pd
 import rioxarray as rxr
 import tomli
+import tomli_w
 import xarray as xr
 from hydromt_fiat import FiatModel as HydromtFiatModel
 from hydromt_fiat.data_apis.open_street_maps import get_buildings_from_osm
 from hydromt_sfincs import SfincsModel as HydromtSfincsModel
 from pydantic import BaseModel, Field
 from shapely import MultiLineString, MultiPolygon, Polygon
+from shapely.ops import nearest_points
 
 from flood_adapt.adapter.fiat_adapter import _FIAT_COLUMNS
 from flood_adapt.config.fiat import (
@@ -133,6 +135,31 @@ def path_check(str_path: str, config_path: Optional[Path] = None) -> str:
     return path.as_posix()
 
 
+def make_relative(str_path: str | Path, toml_path: Path) -> str:
+    """Make a path relative to the config file path.
+
+    Parameters
+    ----------
+    str_path : str | Path
+        The path to be made relative.
+    toml_path : Path
+        The path to the config file.
+
+    Returns
+    -------
+    str
+        The relative path as a string.
+    """
+    path = Path(str_path)
+    if not path.is_absolute():
+        return path.as_posix()
+    try:
+        relative_path = path.relative_to(toml_path.parent)
+        return relative_path.as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
 class SpatialJoinModel(BaseModel):
     """
     Model for representing a spatial join between geometries and tabular data.
@@ -421,6 +448,8 @@ class ConfigModel(BaseModel):
         config.database_path = path_check(config.database_path, toml_path)
         config.fiat = path_check(config.fiat, toml_path)
         config.sfincs_overland.name = path_check(config.sfincs_overland.name, toml_path)
+        if config.dem:
+            config.dem.filename = path_check(config.dem.filename, toml_path)
         if config.sfincs_offshore:
             config.sfincs_offshore.name = path_check(
                 config.sfincs_offshore.name, toml_path
@@ -445,6 +474,67 @@ class ConfigModel(BaseModel):
 
         return config
 
+    def write(self, toml_path: Path) -> None:
+        """
+        Write the configuration model to a TOML file.
+
+        Parameters
+        ----------
+        toml_path : Path
+            The path to the TOML file where the configuration will be saved.
+        """
+        config_dict = self.model_dump(exclude_none=True)
+
+        # Make paths relative to the config file
+        config_dict["database_path"] = make_relative(
+            config_dict["database_path"], toml_path
+        )
+        config_dict["fiat"] = make_relative(config_dict["fiat"], toml_path)
+        config_dict["sfincs_overland"]["name"] = make_relative(
+            config_dict["sfincs_overland"]["name"], toml_path
+        )
+        if self.dem:
+            config_dict["dem"]["filename"] = make_relative(
+                config_dict["dem"]["filename"], toml_path
+            )
+        if config_dict.get("sfincs_offshore"):
+            config_dict["sfincs_offshore"]["name"] = make_relative(
+                config_dict["sfincs_offshore"]["name"], toml_path
+            )
+        if isinstance(self.building_footprints, SpatialJoinModel):
+            config_dict["building_footprints"]["file"] = make_relative(
+                config_dict["building_footprints"]["file"], toml_path
+            )
+        if self.tide_gauge and self.tide_gauge.file:
+            config_dict["tide_gauge"]["file"] = make_relative(
+                config_dict["tide_gauge"]["file"], toml_path
+            )
+        if self.svi:
+            config_dict["svi"]["file"] = make_relative(
+                config_dict["svi"]["file"], toml_path
+            )
+        if self.bfe:
+            config_dict["bfe"]["file"] = make_relative(
+                config_dict["bfe"]["file"], toml_path
+            )
+        if self.slr_scenarios:
+            config_dict["slr_scenarios"]["file"] = make_relative(
+                config_dict["slr_scenarios"]["file"], toml_path
+            )
+
+        if config_dict.get("probabilistic_set"):
+            config_dict["probabilistic_set"] = make_relative(
+                config_dict["probabilistic_set"], toml_path
+            )
+
+        if config_dict.get("aggregation_areas"):
+            for ag in config_dict["aggregation_areas"]:
+                ag["file"] = make_relative(ag["file"], toml_path)
+
+        toml_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(toml_path, mode="wb") as fp:
+            tomli_w.dump(config_dict, fp)
+
 
 class DatabaseBuilder:
     _has_roads: bool = False
@@ -472,15 +562,16 @@ class DatabaseBuilder:
     @debug_timer
     def build(self, overwrite: bool = False) -> None:
         # Check if database already exists
-        if self.root.exists() and not overwrite:
-            raise ValueError(
-                f"There is already a Database folder in '{self.root.as_posix()}'."
-            )
-        if self.root.exists() and overwrite:
-            shutil.rmtree(self.root)
-            warnings.warn(
-                f"There is already a Database folder in '{self.root.as_posix()}, which will be overwritten'."
-            )
+        if self.root.exists():
+            if overwrite:
+                shutil.rmtree(self.root)
+                warnings.warn(
+                    f"There is already a Database folder in '{self.root.as_posix()}, which will be overwritten'."
+                )
+            else:
+                raise ValueError(
+                    f"There is already a Database folder in '{self.root.as_posix()}'."
+                )
         # Create database folder
         self.root.mkdir(parents=True)
 
@@ -823,7 +914,7 @@ class DatabaseBuilder:
         exposure[_FIAT_COLUMNS.ground_elevation] = exposure["elev"]
         del exposure["elev"]
 
-        self.fiat_model.exposure.exposure_db = exposure
+        self.fiat_model.exposure.exposure_db = self._clean_suffix_columns(exposure)
 
     def read_damage_unit(self) -> str:
         if self.fiat_model.exposure.damage_unit is None:
@@ -1087,7 +1178,9 @@ class DatabaseBuilder:
                 exposure_csv = exposure_csv.merge(
                     gdf_joined, on=_FIAT_COLUMNS.object_id, how="left"
                 )
-                self.fiat_model.exposure.exposure_db = exposure_csv
+                self.fiat_model.exposure.exposure_db = self._clean_suffix_columns(
+                    exposure_csv
+                )
                 # Update spatial joins in FIAT model
                 if self.fiat_model.spatial_joins["aggregation_areas"] is None:
                     self.fiat_model.spatial_joins["aggregation_areas"] = []
@@ -1149,7 +1242,9 @@ class DatabaseBuilder:
             exposure_csv = exposure_csv.merge(
                 gdf_joined, on=_FIAT_COLUMNS.object_id, how="left"
             )
-            self.fiat_model.exposure.exposure_db = exposure_csv
+            self.fiat_model.exposure.exposure_db = self._clean_suffix_columns(
+                exposure_csv
+            )
             logger.warning(
                 "No aggregation areas were available in the FIAT model and none were provided in the config file. The region file will be used as a mock aggregation area."
             )
@@ -1180,7 +1275,9 @@ class DatabaseBuilder:
             exposure_csv = exposure_csv.merge(
                 buildings_joined, on=_FIAT_COLUMNS.object_id, how="left"
             )
-            self.fiat_model.exposure.exposure_db = exposure_csv
+            self.fiat_model.exposure.exposure_db = self._clean_suffix_columns(
+                exposure_csv
+            )
 
             # Save the spatial file for future use
             svi_path = self.static_path / "templates" / "fiat" / "svi" / "svi.gpkg"
@@ -1199,8 +1296,15 @@ class DatabaseBuilder:
                 "'SVI' column present in the FIAT exposure csv. Vulnerability type infometrics can be produced."
             )
             add_attrs = self.fiat_model.spatial_joins["additional_attributes"]
+            if add_attrs is None:
+                logger.warning(
+                    "'SVI' column present in the FIAT exposure csv, but no spatial join found with the SVI map."
+                )
+                return None
+
             if "SVI" not in [attr["name"] for attr in add_attrs]:
                 logger.warning("No SVI map found to display in the FloodAdapt GUI!")
+                return None
 
             ind = [attr["name"] for attr in add_attrs].index("SVI")
             svi = add_attrs[ind]
@@ -1407,19 +1511,44 @@ class DatabaseBuilder:
             logger.info("Observation points were provided in the config file.")
             obs_points = self.config.obs_point
 
+        model_region = self.sfincs_overland_model.region.union_all()
+
         if self.tide_gauge is not None:
-            logger.info(
-                "A tide gauge has been setup in the database. It will be used as an observation point as well."
-            )
-            obs_points.append(
-                ObsPointModel(
-                    name=self.tide_gauge.name,
-                    description="Tide gauge observation point",
-                    ID=self.tide_gauge.ID,
-                    lon=self.tide_gauge.lon,
-                    lat=self.tide_gauge.lat,
+            # Check if tide gauge is within model domain
+            coord = (
+                gpd.GeoSeries(
+                    gpd.points_from_xy(
+                        x=[self.tide_gauge.lon], y=[self.tide_gauge.lat]
+                    ),
+                    crs="EPSG:4326",
                 )
+                .to_crs(self.sfincs_overland_model.crs)
+                .iloc[0]
             )
+            # Add tide gauge as obs point if within model region
+            if coord.within(model_region):
+                if self.tide_gauge.name is None:
+                    name = "tide_gauge"
+                else:
+                    name = self.tide_gauge.name
+                obs_points.append(
+                    ObsPointModel(
+                        name=name,
+                        description="Tide gauge observation point",
+                        ID=self.tide_gauge.ID,
+                        lon=self.tide_gauge.lon,
+                        lat=self.tide_gauge.lat,
+                    )
+                )
+            else:
+                boundary = model_region.boundary
+                snapped = nearest_points(coord, boundary)[1]
+                distance = us.UnitfulLength(
+                    value=coord.distance(snapped), units=us.UnitTypesLength.meters
+                )
+                logger.warning(
+                    f"Tide gauge lies outside the model domain by {distance}. It will not be used as an observation point in FloodAdapt."
+                )
 
         if not obs_points:
             logger.warning(
@@ -1427,20 +1556,25 @@ class DatabaseBuilder:
             )
             return None
 
+        # Check if all obs points are within model domain
         lon = [p.lon for p in obs_points]
         lat = [p.lat for p in obs_points]
         names = [p.name for p in obs_points]
         coords = gpd.GeoDataFrame(
-            {"names": names},
+            {"name": names},
             geometry=gpd.points_from_xy(lon, lat),
             crs="EPSG:4326",
         )
         coords = coords.to_crs(self.sfincs_overland_model.crs)
-        model_region = self.sfincs_overland_model.region.union_all()
         valid_coords = coords.within(model_region)
         if not valid_coords.all():
             invalid = coords.loc[~valid_coords, "name"].tolist()
-            raise ValueError(f"Observation points outside model domain: {invalid}")
+            lat = coords.loc[~valid_coords].geometry.y.tolist()
+            lon = coords.loc[~valid_coords].geometry.x.tolist()
+            bounds = model_region.bounds
+            raise ValueError(
+                f"Observation points outside model domain: {invalid}, {lat=}, {lon=}, {bounds=}"
+            )
 
         return obs_points
 
@@ -1533,7 +1667,7 @@ class DatabaseBuilder:
             db_file_path.parent.mkdir(parents=True, exist_ok=True)
             shutil.copyfile(self.config.tide_gauge.file, db_file_path)
 
-            rel_db_path = Path(db_file_path.relative_to(self.static_path))
+            rel_db_path = Path(db_file_path.relative_to(self.static_path)).as_posix()
             logger.warning(
                 f"Tide gauge from file {rel_db_path} assumed to be in {self.unit_system.default_length_units}!"
             )
@@ -1665,26 +1799,22 @@ class DatabaseBuilder:
         if self.sfincs_offshore_model is None:
             return None
         # Connect boundary points of overland to output points of offshore
+        # First read in the boundary locations from the overland model
         fn = Path(self.sfincs_overland_model.root) / "sfincs.bnd"
-        bnd = pd.read_csv(fn, sep=" ", lineterminator="\n", header=None)
-        bnd = bnd.rename(columns={0: "x", 1: "y"})
-        bnd_geo = gpd.GeoDataFrame(
-            bnd,
-            geometry=gpd.points_from_xy(bnd.x, bnd.y),
+        lines = []
+        if fn.exists():
+            with open(fn) as f:
+                lines = f.readlines()
+        coords = [(float(line.split()[0]), float(line.split()[1])) for line in lines]
+        x, y = zip(*coords)
+        bnd = gpd.GeoDataFrame(
+            geometry=gpd.points_from_xy(x, y),
             crs=self.sfincs_overland_model.config["epsg"],
         )
-        obs_geo = bnd_geo.to_crs(4326)
-        obs_geo["x"] = obs_geo.geometry.x
-        obs_geo["y"] = obs_geo.geometry.y
-        del obs_geo["geometry"]
-        obs_geo["name"] = [f"bnd_pt{num:02d}" for num in range(1, len(obs_geo) + 1)]
-        fn_off = Path(self.sfincs_offshore_model.root) / "sfincs.obs"
-        obs_geo.to_csv(
-            fn_off,
-            sep="\t",
-            index=False,
-            header=False,
-        )
+        # Then transform points to offshore crs and save them as observation points
+        obs_geo = bnd.to_crs(self.sfincs_offshore_model.config["epsg"])
+        self.sfincs_offshore_model.setup_observation_points(obs_geo)
+        self.sfincs_offshore_model.write()
         logger.info(
             "Output points of the offshore SFINCS model were reconfigured to the boundary points of the overland SFINCS model."
         )
@@ -1973,12 +2103,12 @@ class DatabaseBuilder:
 
         self.metrics = metrics
 
-    def _create_mandatory_metrics(self, metrics):
+    def _create_mandatory_metrics(self, metrics: Metrics):
         metrics.create_mandatory_metrics_event()
         if self._probabilistic_set_name is not None:
             metrics.create_mandatory_metrics_risk()
 
-    def _create_event_infographics(self, metrics):
+    def _create_event_infographics(self, metrics: Metrics):
         exposure_type = self._get_exposure_type()
         # If not specific infographic config is given, create a standard one
         if not self.config.event_infographics:
@@ -2010,7 +2140,7 @@ class DatabaseBuilder:
             )
         metrics.create_infographics_metrics_event(config=self.config.event_infographics)
 
-    def _create_risk_infographics(self, metrics):
+    def _create_risk_infographics(self, metrics: Metrics):
         exposure_type = self._get_exposure_type()
         # If not specific infographic config is given, create a standard one
         if not self.config.risk_infographics:
@@ -2027,17 +2157,17 @@ class DatabaseBuilder:
                 )
         metrics.create_infographics_metrics_risk(config=self.config.risk_infographics)
 
-    def _add_additional_event_metrics(self, metrics):
+    def _add_additional_event_metrics(self, metrics: Metrics):
         if self.config.event_additional_infometrics:
             for metric in self.config.event_additional_infometrics:
                 metrics.add_event_metric(metric)
 
-    def _add_additional_risk_metrics(self, metrics):
+    def _add_additional_risk_metrics(self, metrics: Metrics):
         if self.config.risk_additional_infometrics:
             for metric in self.config.risk_additional_infometrics:
                 metrics.add_risk_metric(metric)
 
-    def _write_infometrics(self, metrics, path_im, path_ig):
+    def _write_infometrics(self, metrics: Metrics, path_im: Path, path_ig: Path):
         if self._aggregation_areas is None:
             self._aggregation_areas = self.create_aggregation_areas()
         aggr_levels = [aggr.name for aggr in self._aggregation_areas]
@@ -2216,7 +2346,7 @@ class DatabaseBuilder:
 
         # Set model building footprints
         self.fiat_model.building_footprint = building_footprints
-        self.fiat_model.exposure.exposure_db = exposure_csv
+        self.fiat_model.exposure.exposure_db = self._clean_suffix_columns(exposure_csv)
 
         # Save site attributes
         buildings_path = geo_path.relative_to(self.static_path)
@@ -2483,6 +2613,11 @@ class DatabaseBuilder:
         """
         # Make sure only csv objects have geometries
         for i, geoms in enumerate(self.fiat_model.exposure.exposure_geoms):
+            if _FIAT_COLUMNS.object_id not in geoms.columns:
+                logger.warning(
+                    f"Geometry '{self.fiat_model.exposure.geom_names[i]}' does not have an '{_FIAT_COLUMNS.object_id}' column and will be ignored."
+                )
+                continue
             keep = geoms[_FIAT_COLUMNS.object_id].isin(
                 self.fiat_model.exposure.exposure_db[_FIAT_COLUMNS.object_id]
             )
@@ -2523,6 +2658,35 @@ class DatabaseBuilder:
 
         return gdf
 
+    @staticmethod
+    def _clean_suffix_columns(df: pd.DataFrame) -> pd.DataFrame:
+        """Detect and resolves duplicate columns with _x/_y suffixes that appear after a pandas merge.
+
+        (e.g., 'Aggregation Label: Census Blockgroup_x' and 'Aggregation Label: Census Blockgroup_y').
+
+        Keeps the first non-null column of each pair and removes redundant ones.
+        """
+        cols = df.columns.tolist()
+        suffix_pairs = {}
+
+        for col in cols:
+            if col.endswith("_x"):
+                base = col[:-2]
+                if f"{base}_y" in df.columns:
+                    suffix_pairs[base] = (f"{base}_x", f"{base}_y")
+
+        for base, (col_x, col_y) in suffix_pairs.items():
+            # If both columns exist, prefer the one with more non-null values
+            x_notna = df[col_x].notna().sum()
+            y_notna = df[col_y].notna().sum()
+            keep_col = col_x if x_notna >= y_notna else col_y
+            df[base] = df[keep_col]
+
+            # Drop the old suffixed versions
+            df = df.drop(columns=[col_x, col_y])
+
+        return df
+
 
 def create_database(config: Union[str, Path, ConfigModel], overwrite=False) -> None:
     """Create a new database from a configuration file or ConfigModel.

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/dbs_classes/dbs_scenario.py

@@ -79,7 +79,8 @@ class DbsScenario(DbsTemplate[Scenario]):
         """
         event_left = self._database.events.get(left.event)
         event_right = self._database.events.get(right.event)
-        equal_events = event_left == event_right
+        # Deep-compare events including forcing data contents
+        equal_events = event_left.data_equivalent(event_right)
 
         left_projection = self._database.projections.get(left.projection)
         right_projection = self._database.projections.get(right.projection)

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/objects/events/events.py

@@ -117,6 +117,63 @@ class Event(Object):
         for forcing in self.get_forcings():
             forcing.save_additional(output_dir)
 
+    def data_equivalent(self, other: "Event") -> bool:
+        """Deep-compare two events, including forcing data contents.
+
+        Compares core attributes (time, template, mode, rainfall_multiplier) and then
+        verifies that each forcing (by type) has the same data fingerprint. For
+        path-based forcings, the fingerprint hashes the file bytes; for others,
+        a canonical attribute-based hash is used.
+
+        Parameters
+        ----------
+        other : Event
+            The event to compare against.
+
+        Returns
+        -------
+        bool
+            True when events are equivalent in terms of their hazard inputs.
+        """
+        if not isinstance(other, Event):
+            return False
+
+        # Compare high-level attributes first
+        if (
+            self.template != other.template
+            or self.mode != other.mode
+            or self.rainfall_multiplier != other.rainfall_multiplier
+            or self.time != other.time
+        ):
+            return False
+
+        # Compare allowed forcing types present in each event
+        if set(self.forcings.keys()) != set(other.forcings.keys()):
+            return False
+
+        # Build comparable, sorted fingerprint lists per forcing type
+        def fingerprints(evt: "Event") -> dict[ForcingType, list[tuple[str, str]]]:
+            d: dict[ForcingType, list[tuple[str, str]]] = {}
+            for ftype, flist in evt.forcings.items():
+                fps: list[tuple[str, str]] = []
+                for f in flist:
+                    # Include source and the fingerprint to guard against collisions across different sources
+                    src = f.source.value if hasattr(f, "source") else ""
+                    fp = f.content_fingerprint()  # type: ignore[attr-defined]
+                    fps.append((src, fp))
+                # Sort for order-insensitive comparison
+                d[ftype] = sorted(fps, key=lambda t: (t[0], t[1]))
+            return d
+
+        left_fp = fingerprints(self)
+        right_fp = fingerprints(other)
+
+        for ftype in left_fp.keys():
+            if left_fp[ftype] != right_fp[ftype]:
+                return False
+
+        return True
+
     @classmethod
     def load_file(cls, file_path: Path | str | os.PathLike) -> "Event":
         """Load object from file.

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/objects/forcing/forcing.py

@@ -1,3 +1,5 @@
+import hashlib
+import json
 import os
 from abc import ABC, abstractmethod
 from enum import Enum
@@ -72,7 +74,7 @@ class IForcing(BaseModel, ABC):
 
     def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
         """Save additional data of the forcing."""
-        return
+        pass
 
     @field_serializer("path", check_fields=False)
     @classmethod
@@ -80,6 +82,49 @@ class IForcing(BaseModel, ABC):
         """Serialize filepath-like fields by saving only the filename. It is assumed that the file will be saved in the same directory."""
         return value.name
 
+    def content_fingerprint(self) -> str:
+        """Return a stable fingerprint of the forcing's underlying data.
+
+        - If a file-backed `path` attribute exists and the file exists, hash its bytes (SHA-256).
+        - Otherwise, hash a canonical JSON dump of the model (excluding volatile fields like `path`).
+
+        Returns
+        -------
+        str
+            A fingerprint string that changes when the forcing's effective data changes.
+        """
+        # Prefer hashing the actual file content when available
+        try:
+            p = getattr(self, "path", None)
+            if isinstance(p, Path) and p and p.exists():
+                sha = hashlib.sha256()
+                with p.open("rb") as f:
+                    for chunk in iter(lambda: f.read(8192), b""):
+                        sha.update(chunk)
+                # Include filename to disambiguate multi-forcing scenarios with identical content
+                return f"FILE:{p.name}:{sha.hexdigest()}"
+        except Exception:
+            # Fall through to attribute-based hashing if anything goes wrong
+            pass
+
+        # Fallback: hash the model attributes (excluding volatile fields like path)
+        data = self.model_dump(exclude_none=True)
+        # Remove potentially non-stable/absolute fields
+        data.pop("path", None)
+
+        # Ensure enums are serialized to their values for stable hashing
+        if isinstance(data.get("type"), Enum):
+            data["type"] = data["type"].value
+        if isinstance(data.get("source"), Enum):
+            data["source"] = data["source"].value
+
+        payload = json.dumps(data, sort_keys=True, default=str).encode("utf-8")
+        return f"ATTR:{hashlib.sha256(payload).hexdigest()}"
+
+    def _post_load(self, file_path: Path | str | os.PathLike, **kwargs) -> None:
+        """Post-load hook, called at the end of `load_file`, to perform any additional loading steps after loading from file."""
+        return
+
 
 class IDischarge(IForcing):
     type: ForcingType = ForcingType.DISCHARGE

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/objects/forcing/tide_gauge.py

@@ -8,6 +8,7 @@ import requests
 from noaa_coops.station import COOPSAPIError
 from pydantic import BaseModel, model_validator
 
+from flood_adapt.config import Settings
 from flood_adapt.misc.log import FloodAdaptLogging
 from flood_adapt.objects.forcing import unit_system as us
 from flood_adapt.objects.forcing.time_frame import TimeFrame
@@ -56,7 +57,7 @@ class TideGauge(BaseModel):
     source: TideGaugeSource
     reference: str
     ID: Optional[int] = None  # Attribute used to download from correct gauge
-    file: Optional[Path] = None  # for locally stored data
+    file: Optional[str] = None  # for locally stored data
     lat: Optional[float] = None
     lon: Optional[float] = None
     units: us.UnitTypesLength = (
@@ -104,7 +105,8 @@ class TideGauge(BaseModel):
         """
         logger.info(f"Retrieving waterlevels for tide gauge {self.ID} for {time}")
         if self.file:
-            gauge_data = self._read_imported_waterlevels(time=time, path=self.file)
+            abs_path = Settings().database_path / "static" / self.file
+            gauge_data = self._read_imported_waterlevels(time=time, path=abs_path)
         else:
             gauge_data = self._download_tide_gauge_data(time=time)
 

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt/objects/forcing/unit_system.py

@@ -110,10 +110,12 @@ class ValueUnitPair(ABC, BaseModel, Generic[TUnit]):
         raise ValueError(f"Unsupported or unknown unit: {str_unit}")
 
     def __str__(self) -> str:
-        return f"{self.value} {self.units.value}"
+        return f"{self.value:.2f} {self.units.value}"
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}(value={self.value}, units={self.units})"
+        return (
+            f"{type(self).__name__}(value={self.value:.2f}, units={self.units.value})"
+        )
 
     def __sub__(self: TClass, other: TClass) -> TClass:
         if not isinstance(other, type(self)):

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flood-adapt
-Version: 1.1.3
+Version: 1.1.5
 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: ====================================================
@@ -712,14 +712,12 @@ Requires-Dist: cht-cyclones<2.0,>=1.0.3
 Requires-Dist: cht-meteo<1.0,>=0.3.1
 Requires-Dist: cht-observations<1.0,>=0.2.1
 Requires-Dist: cht-tide<1.0,>=0.1.1
-Requires-Dist: dask==2024.11.2
-Requires-Dist: numba_celltree==0.2.2
 Requires-Dist: fiat-toolbox<0.2.0,>=0.1.22
 Requires-Dist: fiona<2.0,>=1.0
 Requires-Dist: geojson<4.0,>=3.0
 Requires-Dist: geopandas<2.0,>=1.0
 Requires-Dist: hydromt-fiat<1.0,>=0.5.9
-Requires-Dist: hydromt-sfincs<2.0,>=1.2.0
+Requires-Dist: hydromt-sfincs<2.0,>=1.2.2
 Requires-Dist: numpy<2.0,>=1.0
 Requires-Dist: numpy-financial<2.0,>=1.0
 Requires-Dist: pandas<3.0,>=2.0

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/flood_adapt.egg-info/requires.txt

@@ -2,14 +2,12 @@ cht-cyclones<2.0,>=1.0.3
 cht-meteo<1.0,>=0.3.1
 cht-observations<1.0,>=0.2.1
 cht-tide<1.0,>=0.1.1
-dask==2024.11.2
-numba_celltree==0.2.2
 fiat-toolbox<0.2.0,>=0.1.22
 fiona<2.0,>=1.0
 geojson<4.0,>=3.0
 geopandas<2.0,>=1.0
 hydromt-fiat<1.0,>=0.5.9
-hydromt-sfincs<2.0,>=1.2.0
+hydromt-sfincs<2.0,>=1.2.2
 numpy<2.0,>=1.0
 numpy-financial<2.0,>=1.0
 pandas<3.0,>=2.0

{flood_adapt-1.1.3 → flood_adapt-1.1.5}/pyproject.toml

@@ -30,14 +30,12 @@ dependencies = [
     "cht-meteo          >=0.3.1,<1.0",
     "cht-observations   >=0.2.1,<1.0",
     "cht-tide           >=0.1.1,<1.0",
-    "dask               ==2024.11.2",   # not a dependency, but a we need to use this version
-    "numba_celltree     ==0.2.2",       # not a dependency, but a we need to use this version
     "fiat-toolbox       >=0.1.22,<0.2.0",
     "fiona              >=1.0,<2.0",
     "geojson            >=3.0,<4.0",
     "geopandas          >=1.0,<2.0",
     "hydromt-fiat       >=0.5.9,<1.0",
-    "hydromt-sfincs     >=1.2.0,<2.0",
+    "hydromt-sfincs     >=1.2.2,<2.0",
     "numpy              >=1.0,<2.0",
     "numpy-financial    >=1.0,<2.0",
     "pandas             >=2.0,<3.0",