flood-adapt 1.0.4__tar.gz → 1.1.0__tar.gz

{flood_adapt-1.0.4 → flood_adapt-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flood-adapt
-Version: 1.0.4
+Version: 1.1.0
 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: ====================================================
@@ -714,7 +714,7 @@ Requires-Dist: cht-observations==0.2.1
 Requires-Dist: cht-tide==0.1.1
 Requires-Dist: dask==2024.11.2
 Requires-Dist: numba_celltree==0.2.2
-Requires-Dist: fiat-toolbox==0.1.20
+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
@@ -723,7 +723,7 @@ Requires-Dist: hydromt-sfincs==1.2.0
 Requires-Dist: numpy<2.0,>=1.0
 Requires-Dist: numpy-financial<2.0,>=1.0
 Requires-Dist: pandas<3.0,>=2.0
-Requires-Dist: plotly<7.0,>=6.0
+Requires-Dist: plotly<6.3,>=6.0
 Requires-Dist: pydantic<3.0,>=2.0
 Requires-Dist: pydantic-settings<3.0,>=2.0
 Requires-Dist: pyogrio<1.0

{flood_adapt-1.0.4 → flood_adapt-1.1.0}/flood_adapt/__init__.py

@@ -1,11 +1,11 @@
 # has to be here at the start to avoid circular imports
-__version__ = "1.0.4"
+__version__ = "1.1.0"
 
 from flood_adapt import adapter, database_builder, dbs_classes, objects
 from flood_adapt.config.config import Settings
 from flood_adapt.config.site import Site
 from flood_adapt.flood_adapt import FloodAdapt
-from flood_adapt.misc.exceptions import ComponentError, DatabaseError, FloodAdaptError
+from flood_adapt.misc.exceptions import DatabaseError, FloodAdaptError
 from flood_adapt.misc.log import FloodAdaptLogging
 from flood_adapt.objects.forcing import unit_system
 
@@ -21,7 +21,6 @@ __all__ = [
     "database_builder",
     "FloodAdaptError",
     "DatabaseError",
-    "ComponentError",
 ]
 
 FloodAdaptLogging()  # Initialize logging once for the entire package

{flood_adapt-1.0.4 → flood_adapt-1.1.0}/flood_adapt/adapter/fiat_adapter.py

@@ -205,7 +205,7 @@ class FiatAdapter(IImpactAdapter):
         self.close_files()
         if self.model_root.exists():
             logger.info(f"Deleting {self.model_root}")
-            shutil.rmtree(self.model_root)
+            shutil.rmtree(self.model_root, ignore_errors=True)
 
     def fiat_completed(self) -> bool:
         """Check if fiat has run as expected.
@@ -353,7 +353,7 @@ class FiatAdapter(IImpactAdapter):
                             os.remove(os.path.join(subdir, file))
 
                     if not os.listdir(subdir):
-                        os.rmdir(subdir)
+                        shutil.rmtree(subdir, ignore_errors=True)
 
             if strict:
                 raise RuntimeError(f"FIAT model failed to run in {path}.")
@@ -1365,6 +1365,11 @@ class FiatAdapter(IImpactAdapter):
             True,
             True,
         ]
+        metrics_new.loc["Show In Metrics Map", ["EW", "EWEAD", "EWCEAD"]] = [
+            False,
+            True,
+            False,
+        ]
         metrics_new.loc["Long Name", ["EW", "EWEAD", "EWCEAD"]] = [
             "Equity weight",
             "Equity weighted  expected annual damage",
@@ -1574,5 +1579,5 @@ class FiatAdapter(IImpactAdapter):
         )
         if simulation_path.exists():
             self.close_files()
-            shutil.rmtree(simulation_path)
+            shutil.rmtree(simulation_path, ignore_errors=True)
             logger.info(f"Deleted Delft-FIAT simulation folder: {simulation_path}")

{flood_adapt-1.0.4 → flood_adapt-1.1.0}/flood_adapt/adapter/sfincs_adapter.py

@@ -212,7 +212,7 @@ class SfincsAdapter(IHazardAdapter):
                             os.remove(os.path.join(subdir, file))
 
                     if not os.listdir(subdir):
-                        os.rmdir(subdir)
+                        shutil.rmtree(subdir, ignore_errors=True)
 
             if strict:
                 raise RuntimeError(f"SFINCS model failed to run in {path}.")
@@ -828,7 +828,7 @@ class SfincsAdapter(IHazardAdapter):
 
         if sim_path.parent.exists() and not any(sim_path.parent.iterdir()):
             # Remove the parent directory `simulations` if it is empty
-            sim_path.parent.rmdir()
+            shutil.rmtree(sim_path.parent, ignore_errors=True)
 
     def _run_risk_scenario(self, scenario: Scenario):
         """Run the whole workflow for a risk scenario.

{flood_adapt-1.0.4 → flood_adapt-1.1.0}/flood_adapt/adapter/sfincs_offshore.py

@@ -97,7 +97,7 @@ class OffshoreSfincsHandler(IOffshoreSfincsHandler, DatabaseUser):
         sim_path = self._get_simulation_path()
         # SfincsAdapter.write() doesnt write the bca file apparently so we need to copy the template
         if sim_path.exists():
-            shutil.rmtree(sim_path)
+            shutil.rmtree(sim_path, ignore_errors=True)
 
         with SfincsAdapter(model_root=self.template_path) as _offshore_model:
             # Load objects, set root & write template model

{flood_adapt-1.0.4 → flood_adapt-1.1.0}/flood_adapt/config/fiat.py

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

{flood_adapt-1.0.4 → flood_adapt-1.1.0}/flood_adapt/config/gui.py

@@ -1,5 +1,7 @@
+import re
+from enum import Enum
 from pathlib import Path
-from typing import Optional
+from typing import Any, Literal, Optional, Union
 
 import geopandas as gpd
 import numpy as np
@@ -25,6 +27,7 @@ class Layer(BaseModel):
 
     bins: list[float]
     colors: list[str]
+    decimals: Optional[int] = 0
 
     @model_validator(mode="after")
     def check_bins_and_colors(self) -> "Layer":
@@ -42,20 +45,118 @@ class FloodMapLayer(Layer):
     roads_min_zoom_level: int = 14
 
 
-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 LogicalOperator(str, Enum):
+    AND = "and"
+    OR = "or"
+
+
+class FieldName(str, Enum):
+    """Enum for valid field names with mapping to dictionary keys."""
+
+    NAME = "name"
+    LONG_NAME = "long_name"
+    DESCRIPTION = "description"
+
+    @property
+    def dict_key(self) -> str:
+        """Get the actual dictionary key for this field name."""
+        mapping = {
+            "name": "name",
+            "long_name": "Long Name",
+            "description": "Description",
+        }
+        return mapping[self.value]
+
+
+class FilterCondition(BaseModel):
+    """A single filter condition."""
+
+    field_name: FieldName
+    values: list[Any]
+    operator: LogicalOperator = (
+        LogicalOperator.OR
+    )  # How to combine values within this condition
+
+
+class FilterGroup(BaseModel):
+    """A group of filter conditions with logical operators."""
+
+    conditions: list[FilterCondition]
+    operator: LogicalOperator = (
+        LogicalOperator.OR
+    )  # How to combine conditions within this group
+
+
+class MetricLayer(Layer):
+    type: str
+    # Simplified: just a single FilterGroup or FilterCondition
+    filters: Union[FilterGroup, FilterCondition] = Field(
+        default_factory=lambda: FilterGroup(conditions=[])
+    )
+
+    def matches(self, data_dict: dict) -> bool:
+        """Check if the given data dictionary matches the filter criteria."""
+        if isinstance(self.filters, FilterCondition):
+            return self._evaluate_condition(self.filters, data_dict)
+        else:  # FilterGroup
+            return self._evaluate_filter_group(self.filters, data_dict)
+
+    def _evaluate_filter_group(self, group: FilterGroup, data_dict: dict) -> bool:
+        """Evaluate a single filter group."""
+        if not group.conditions:
+            return True
+
+        condition_results = []
+        for condition in group.conditions:
+            condition_results.append(self._evaluate_condition(condition, data_dict))
+
+        if group.operator == LogicalOperator.AND:
+            return all(condition_results)
+        else:  # OR
+            return any(condition_results)
+
+    def _evaluate_condition(self, condition: FilterCondition, data_dict: dict) -> bool:
+        """Evaluate a single condition."""
+        # Use the dict_key property to get the actual dictionary key
+        field_value = data_dict.get(condition.field_name.dict_key)
+        if field_value is None:
+            return False
+
+        value_matches = [value in field_value for value in condition.values]  # noqa: PD011
+
+        if condition.operator == LogicalOperator.AND:
+            return all(value_matches)
+        else:  # OR
+            return any(value_matches)
+
+
+class AggregationDmgLayer(MetricLayer):
+    type: str = "damage"
+    filters: FilterGroup = Field(
+        default_factory=lambda: FilterGroup(
+            conditions=[
+                FilterCondition(
+                    field_name=FieldName.NAME,
+                    values=[
+                        "TotalDamageEvent",
+                        "ExpectedAnnualDamages",
+                        "TotalDamageRP",
+                        "EWEAD",
+                    ],
+                )
+            ]
+        )
+    )
+
+
 class OutputLayers(BaseModel):
     """The configuration of the mapbox layers in the gui.
 
@@ -75,9 +176,84 @@ class OutputLayers(BaseModel):
     floodmap: FloodMapLayer
     aggregation_dmg: AggregationDmgLayer
     footprints_dmg: FootprintsDmgLayer
-
+    aggregated_metrics: list[MetricLayer] = Field(default_factory=list)
     benefits: Optional[BenefitsLayer] = None
 
+    def get_aggr_metrics_layers(
+        self,
+        metrics: list[dict],
+        type: Literal["single_event", "risk"] = "single_event",
+        rp: Optional[int] = None,
+        equity: bool = False,
+    ):
+        layer_types = [self.aggregation_dmg] + self.aggregated_metrics
+        filtered_input_metrics = self._filter_metrics(metrics, type, rp, equity)
+        return self._match_metrics_to_layers(filtered_input_metrics, layer_types)
+
+    def _should_skip_metric(
+        self, metric_name: str, rp: Optional[int], equity: bool
+    ) -> bool:
+        rp_match = re.search(r"RP(\d+)", metric_name)
+        y_match = re.search(r"(\d+)Y", metric_name)
+        name_match = rp_match or y_match
+
+        if rp is None:
+            if name_match:
+                return True
+            if not equity and "EW" in metric_name:
+                return True
+            if equity and "EW" not in metric_name:
+                return True
+        return False
+
+    def _process_metric_name(
+        self, metric_name: str, rp: Optional[int]
+    ) -> tuple[str, bool]:
+        rp_match = re.search(r"RP(\d+)", metric_name)
+        y_match = re.search(r"(\d+)Y", metric_name)
+        name_match = rp_match or y_match
+        if rp is not None:
+            if name_match:
+                extracted_rp = int(name_match.group(1))
+                name_check = extracted_rp == int(rp)
+                cleaned_name = re.sub(r"(RP\d+|\d+Y)", "", metric_name)
+                return cleaned_name.rstrip("_"), name_check
+            else:
+                return metric_name, False
+        return metric_name, True
+
+    def _filter_metrics(self, metrics, type, rp, equity):
+        filtered = []
+        for metric in metrics:
+            metric_name = metric.get("name", "")
+            metric["name_to_show"] = metric_name
+            if type == "risk":
+                if self._should_skip_metric(metric_name, rp, equity):
+                    continue
+                metric["name_to_show"], name_check = self._process_metric_name(
+                    metric_name, rp
+                )
+                if rp is not None and not name_check:
+                    continue
+            filtered.append(metric)
+        return filtered
+
+    def _match_metrics_to_layers(self, metrics, layer_types):
+        filtered_metrics = []
+        for metric in metrics:
+            for layer in layer_types:
+                if layer.matches(metric):
+                    filtered_metrics.append(
+                        {
+                            "metric": metric,
+                            "bins": getattr(layer, "bins", None),
+                            "colors": getattr(layer, "colors", None),
+                            "decimals": getattr(layer, "decimals", None),
+                        }
+                    )
+                    break
+        return filtered_metrics
+
 
 class VisualizationLayer(Layer):
     """The configuration of a layer to visualize in the gui.
@@ -157,6 +333,7 @@ class VisualizationLayers(BaseModel):
         The layers to visualize.
     """
 
+    buildings_min_zoom_level: int = 13
     layers: list[VisualizationLayer] = Field(default_factory=list)
 
     def add_layer(