flood-adapt 0.3.0__py3-none-any.whl → 0.3.2__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.0"
+__version__ = "0.3.2"
 
 from flood_adapt import adapter, dbs_classes, objects
 from flood_adapt.config.config import Settings

flood_adapt/config/fiat.py

@@ -198,18 +198,18 @@ class FiatModel(BaseModel):
 
     Attributes
     ----------
-    risk : RiskModel
-        Configuration of probabilistic risk runs.
+    risk : Optional[RiskModel]
+        Configuration of probabilistic risk runs. default=None
     config : FiatConfigModel
         Configuration for the FIAT model.
-    benefits : BenefitsModel
-        Configuration for running benefit calculations.
+    benefits : Optional[BenefitsModel]
+        Configuration for running benefit calculations. default=None
     """
 
-    risk: RiskModel
-
     config: FiatConfigModel
-    benefits: BenefitsModel
+
+    benefits: Optional[BenefitsModel] = None
+    risk: Optional[RiskModel] = None
 
     @staticmethod
     def read_toml(path: Path) -> "FiatModel":

flood_adapt/config/site.py

@@ -26,8 +26,8 @@ class Site(BaseModel):
     ----------
     name : str
         Name of the site.
-    description : str, default=""
-        Description of the site.
+    description : str
+        Description of the site. Defaults to "".
     lat : float
         Latitude of the site.
     lon : float

flood_adapt/database_builder/database_builder.py

@@ -379,6 +379,7 @@ class DatabaseBuilder:
 
     _has_roads: bool = False
     _aggregation_areas: Optional[list] = None
+    _probabilistic_set_name: Optional[str] = None
 
     def __init__(self, config: ConfigModel, overwrite: bool = True):
         self.config = config
@@ -579,19 +580,26 @@ class DatabaseBuilder:
     ### FIAT ###
     def create_fiat_model(self) -> FiatModel:
         fiat = FiatModel(
-            risk=self.create_risk_model(),
             config=self.create_fiat_config(),
             benefits=self.create_benefit_config(),
+            risk=self.create_risk_model(),
         )
         return fiat
 
-    def create_risk_model(self) -> RiskModel:
+    def create_risk_model(self) -> Optional[RiskModel]:
         # Check if return periods are provided
         if not self.config.return_periods:
-            risk = RiskModel()
-            self.logger.warning(
-                f"Return periods for risk calculations not provided. Default values of {risk.return_periods} will be used."
-            )
+            if self._probabilistic_set_name:
+                risk = RiskModel()
+                self.logger.warning(
+                    f"No return periods provided, but a probabilistic set is available. Using default return periods {risk.return_periods}."
+                )
+                return risk
+            else:
+                self.logger.warning(
+                    "No return periods provided and no probabilistic set available. Risk calculations will not be performed."
+                )
+                return None
         else:
             risk = RiskModel(return_periods=self.config.return_periods)
         return risk

flood_adapt/dbs_classes/database.py

@@ -2,9 +2,8 @@ import gc
 import os
 import shutil
 import time
-from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 import geopandas as gpd
 import numpy as np
@@ -566,7 +565,12 @@ class Database(IDatabase):
             gdfs[label] = gdfs[label].to_crs(4326)
         return gdfs
 
-    def get_object_list(self, object_type: str) -> dict[str, Any]:
+    def get_object_list(
+        self,
+        object_type: Literal[
+            "projections", "events", "measures", "strategies", "scenarios", "benefits"
+        ],
+    ) -> dict[str, Any]:
         """Get a dictionary with all the toml paths and last modification dates that exist in the database that correspond to object_type.
 
         Parameters
@@ -579,20 +583,23 @@ class Database(IDatabase):
         dict[str, Any]
             Includes 'path' and 'last_modification_date' info
         """
-        paths = [
-            path / f"{path.name}.toml"
-            for path in list((self.input_path / object_type).iterdir())
-        ]
-        last_modification_date = [
-            datetime.fromtimestamp(file.stat().st_mtime) for file in paths
-        ]
-
-        objects = {
-            "path": paths,
-            "last_modification_date": last_modification_date,
-        }
-
-        return objects
+        match object_type:
+            case "projections":
+                return self.projections.list_objects()
+            case "events":
+                return self.events.list_objects()
+            case "measures":
+                return self.measures.list_objects()
+            case "strategies":
+                return self.strategies.list_objects()
+            case "scenarios":
+                return self.scenarios.list_objects()
+            case "benefits":
+                return self.benefits.list_objects()
+            case _:
+                raise ValueError(
+                    f"Object type '{object_type}' is not valid. Must be one of 'projections', 'events', 'measures', 'strategies' or 'scenarios'."
+                )
 
     def has_run_hazard(self, scenario_name: str) -> None:
         """Check if there is already a simulation that has the exact same hazard component.

flood_adapt/dbs_classes/dbs_event.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from typing import Any
 
 from flood_adapt.dbs_classes.dbs_template import DbsTemplate
 from flood_adapt.objects.events.event_factory import EventFactory
@@ -34,20 +33,6 @@ class DbsEvent(DbsTemplate[Event]):
         # Load event
         return EventFactory.load_file(event_path)
 
-    def list_objects(self) -> dict[str, list[Any]]:
-        """Return a dictionary with info on the events that currently exist in the database.
-
-        Returns
-        -------
-        dict[str, Any]
-            Includes 'name', 'description', 'path' and 'last_modification_date' info
-        """
-        events = self._get_object_list()
-        objects = [self.get(name) for name in events["name"]]
-        events["description"] = [obj.description for obj in objects]
-        events["objects"] = objects
-        return events
-
     def _check_standard_objects(self, name: str) -> bool:
         """Check if an event is a standard event.
 

flood_adapt/dbs_classes/dbs_measure.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Any
 
 import geopandas as gpd
@@ -26,9 +27,15 @@ class DbsMeasure(DbsTemplate[Measure]):
         Measure
             measure object
         """
-        measure_path = self.input_path / name / f"{name}.toml"
-        measure = MeasureFactory.get_measure_object(measure_path)
-        return measure
+        # Make the full path to the object
+        full_path = self.input_path / name / f"{name}.toml"
+
+        # Check if the object exists
+        if not Path(full_path).is_file():
+            raise ValueError(f"{self.display_name}: '{name}' does not exist.")
+
+        # Load and return the object
+        return MeasureFactory.get_measure_object(full_path)
 
     def list_objects(self) -> dict[str, list[Any]]:
         """Return a dictionary with info on the measures that currently exist in the database.
@@ -39,14 +46,15 @@ class DbsMeasure(DbsTemplate[Measure]):
             Includes 'name', 'description', 'path' and 'last_modification_date' info
         """
         measures = self._get_object_list()
-        objects = [MeasureFactory.get_measure_object(path) for path in measures["path"]]
+        objects = [self.get(name) for name in measures["name"]]
+
         measures["description"] = [obj.description for obj in objects]
         measures["objects"] = objects
 
         geometries = []
-        for path, obj in zip(measures["path"], objects):
+        for obj in objects:
             # If polygon is used read the polygon file
-            if obj.polygon_file:
+            if hasattr(obj, "polygon_file") and obj.polygon_file:
                 src_path = resolve_filepath(
                     object_dir=self.dir_name,
                     obj_name=obj.name,
@@ -54,7 +62,7 @@ class DbsMeasure(DbsTemplate[Measure]):
                 )
                 geometries.append(gpd.read_file(src_path))
             # If aggregation area is used read the polygon from the aggregation area name
-            elif obj.aggregation_area_name:
+            elif hasattr(obj, "aggregation_area_name") and obj.aggregation_area_name:
                 if (
                     obj.aggregation_area_type
                     not in self._database.static.get_aggregation_areas()

flood_adapt/dbs_classes/dbs_static.py

@@ -128,11 +128,9 @@ class DbsStatic(IDbsStatic):
         """
         # Read the map
         full_path = self._database.static_path / path
-        if full_path.is_file():
-            return gpd.read_file(full_path, engine="pyogrio").to_crs(4326)
-
-        # If the file is not found, throw an error
-        raise FileNotFoundError(f"File {full_path} not found")
+        if not full_path.is_file():
+            raise FileNotFoundError(f"File {full_path} not found")
+        return gpd.read_file(full_path, engine="pyogrio").to_crs(4326)
 
     @cache_method_wrapper
     def get_slr_scn_names(self) -> list:

flood_adapt/dbs_classes/dbs_template.py

@@ -60,10 +60,9 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
         object_list = self._get_object_list()
 
         # Load all objects
-        objects = [self._object_class.load_file(path) for path in object_list["path"]]
+        objects = [self.get(name) for name in object_list["name"]]
 
-        # From the loaded objects, get the name and description and add them to the object_list
-        object_list["name"] = [obj.name for obj in objects]
+        # From the loaded objects, get the description and add them to the object_list
         object_list["description"] = [obj.description for obj in objects]
         object_list["objects"] = objects
         return object_list
@@ -248,7 +247,7 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
         Returns
         -------
         dict[str, Any]
-            A dictionary that contains the keys: `name` to 'path' and 'last_modification_date'
+            A dictionary that contains the keys: `name` to `path` and `last_modification_date`
             Each key has a list of the corresponding values, where the index of the values corresponds to the same object.
         """
         # If the toml doesnt exist, we might be in the middle of saving a new object or could be a broken object.