flood-adapt 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

flood_adapt/dbs_classes/dbs_benefit.py

@@ -1,76 +1,77 @@
-import shutil
-
-from flood_adapt.dbs_classes.dbs_template import DbsTemplate
-from flood_adapt.workflows.benefit_runner import Benefit, BenefitRunner
-
-
-class DbsBenefit(DbsTemplate[Benefit]):
-    display_name = "Benefit"
-    dir_name = "benefits"
-    _object_class = Benefit
-
-    def save(self, object_model: Benefit, overwrite: bool = False):
-        """Save a benefit object in the database.
-
-        Parameters
-        ----------
-        object_model : Benefit
-            object of Benefit type
-        overwrite : bool, optional
-            whether to overwrite existing benefit with same name, by default False
-
-        Raises
-        ------
-        ValueError
-            Raise error if name is already in use. Names of benefits assessments should be unique.
-        """
-        runner = BenefitRunner(self._database, benefit=object_model)
-
-        # Check if all scenarios are created
-        if not all(runner.scenarios["scenario created"] != "No"):
-            raise ValueError(
-                f"'{object_model.name}' name cannot be created before all necessary scenarios are created."
-            )
-
-        # Save the benefit
-        super().save(object_model, overwrite=overwrite)
-
-    def delete(self, name: str, toml_only: bool = False):
-        """Delete an already existing benefit in the database.
-
-        Parameters
-        ----------
-        name : str
-            name of the benefit
-        toml_only : bool, optional
-            whether to only delete the toml file or the entire folder. If the folder is empty after deleting the toml,
-            it will always be deleted. By default False
-
-        Raises
-        ------
-        ValueError
-            Raise error if benefit has already model output
-        """
-        # First delete the benefit
-        super().delete(name, toml_only=toml_only)
-
-        # Delete output if edited
-        output_path = self.output_path / name
-        if output_path.exists():
-            shutil.rmtree(output_path, ignore_errors=True)
-
-    def get_runner(self, name: str) -> BenefitRunner:
-        return BenefitRunner(self._database, self.get(name))
-
-    def has_run_check(self, name: str) -> bool:
-        return self.get_runner(name).has_run_check()
-
-    def ready_to_run(self, name: str) -> bool:
-        """Check if all the required scenarios have already been run.
-
-        Returns
-        -------
-        bool
-            True if required scenarios have been already run
-        """
-        return self.get_runner(name).ready_to_run()
+import shutil
+
+from flood_adapt.dbs_classes.dbs_template import DbsTemplate
+from flood_adapt.misc.exceptions import DatabaseError
+from flood_adapt.workflows.benefit_runner import Benefit, BenefitRunner
+
+
+class DbsBenefit(DbsTemplate[Benefit]):
+    display_name = "Benefit"
+    dir_name = "benefits"
+    _object_class = Benefit
+
+    def save(self, object_model: Benefit, overwrite: bool = False):
+        """Save a benefit object in the database.
+
+        Parameters
+        ----------
+        object_model : Benefit
+            object of Benefit type
+        overwrite : bool, optional
+            whether to overwrite existing benefit with same name, by default False
+
+        Raises
+        ------
+        DatabaseError
+            Raise error if name is already in use. Names of benefits assessments should be unique.
+        """
+        runner = BenefitRunner(self._database, benefit=object_model)
+
+        # Check if all scenarios are created
+        if not all(runner.scenarios["scenario created"] != "No"):
+            raise DatabaseError(
+                f"'{object_model.name}' name cannot be created before all necessary scenarios are created."
+            )
+
+        # Save the benefit
+        super().save(object_model, overwrite=overwrite)
+
+    def delete(self, name: str, toml_only: bool = False):
+        """Delete an already existing benefit in the database.
+
+        Parameters
+        ----------
+        name : str
+            name of the benefit
+        toml_only : bool, optional
+            whether to only delete the toml file or the entire folder. If the folder is empty after deleting the toml,
+            it will always be deleted. By default False
+
+        Raises
+        ------
+        DatabaseError
+            Raise error if benefit has already model output
+        """
+        # First delete the benefit
+        super().delete(name, toml_only=toml_only)
+
+        # Delete output if edited
+        output_path = self.output_path / name
+        if output_path.exists():
+            shutil.rmtree(output_path, ignore_errors=True)
+
+    def get_runner(self, name: str) -> BenefitRunner:
+        return BenefitRunner(self._database, self.get(name))
+
+    def has_run_check(self, name: str) -> bool:
+        return self.get_runner(name).has_run_check()
+
+    def ready_to_run(self, name: str) -> bool:
+        """Check if all the required scenarios have already been run.
+
+        Returns
+        -------
+        bool
+            True if required scenarios have been already run
+        """
+        return self.get_runner(name).ready_to_run()

flood_adapt/dbs_classes/dbs_event.py

@@ -1,59 +1,61 @@
-from pathlib import Path
-
-from flood_adapt.dbs_classes.dbs_template import DbsTemplate
-from flood_adapt.objects.events.event_factory import EventFactory
-from flood_adapt.objects.events.events import Event
-
-
-class DbsEvent(DbsTemplate[Event]):
-    dir_name = "events"
-    display_name = "Event"
-    _object_class = Event
-
-    def get(self, name: str) -> Event:
-        """Return an event object.
-
-        Parameters
-        ----------
-        name : str
-            name of the event to be returned
-
-        Returns
-        -------
-        Event
-            event object
-        """
-        # Get event path
-        event_path = self.input_path / f"{name}" / f"{name}.toml"
-
-        # Check if the object exists
-        if not Path(event_path).is_file():
-            raise ValueError(f"{self.display_name} '{name}' does not exist.")
-
-        # Load event
-        return EventFactory.load_file(event_path)
-
-    def check_higher_level_usage(self, name: str) -> list[str]:
-        """Check if an event is used in a scenario.
-
-        Parameters
-        ----------
-        name : str
-            name of the event to be checked
-
-        Returns
-        -------
-        list[str]
-            list of scenarios that use the event
-        """
-        # Get all the scenarios
-        scenarios = [
-            self._database.scenarios.get(scn)
-            for scn in self._database.scenarios.summarize_objects()["name"]
-        ]
-
-        # Check if event is used in a scenario
-        used_in_scenario = [
-            scenario.name for scenario in scenarios if name == scenario.event
-        ]
-        return used_in_scenario
+from pathlib import Path
+
+from flood_adapt.dbs_classes.dbs_template import DbsTemplate
+from flood_adapt.misc.exceptions import DatabaseError
+from flood_adapt.objects.events.event_factory import EventFactory
+from flood_adapt.objects.events.event_set import EventSet
+from flood_adapt.objects.events.events import Event
+
+
+class DbsEvent(DbsTemplate[Event]):
+    dir_name = "events"
+    display_name = "Event"
+    _object_class = Event
+
+    def get(self, name: str, load_all: bool = False) -> Event | EventSet:
+        """Return an event object.
+
+        Parameters
+        ----------
+        name : str
+            name of the event to be returned
+
+        Returns
+        -------
+        Event
+            event object
+        """
+        # Get event path
+        event_path = self.input_path / f"{name}" / f"{name}.toml"
+
+        # Check if the object exists
+        if not Path(event_path).is_file():
+            raise DatabaseError(f"{self.display_name} '{name}' does not exist.")
+
+        # Load event
+        return EventFactory.load_file(event_path, load_all=load_all)
+
+    def check_higher_level_usage(self, name: str) -> list[str]:
+        """Check if an event is used in a scenario.
+
+        Parameters
+        ----------
+        name : str
+            name of the event to be checked
+
+        Returns
+        -------
+        list[str]
+            list of scenarios that use the event
+        """
+        # Get all the scenarios
+        scenarios = [
+            self._database.scenarios.get(scn)
+            for scn in self._database.scenarios.summarize_objects()["name"]
+        ]
+
+        # Check if event is used in a scenario
+        used_in_scenario = [
+            scenario.name for scenario in scenarios if name == scenario.event
+        ]
+        return used_in_scenario

flood_adapt/dbs_classes/dbs_measure.py

@@ -1,111 +1,112 @@
-from pathlib import Path
-from typing import Any
-
-import geopandas as gpd
-
-from flood_adapt.dbs_classes.dbs_template import DbsTemplate
-from flood_adapt.misc.utils import resolve_filepath
-from flood_adapt.objects.measures.measure_factory import MeasureFactory
-from flood_adapt.objects.measures.measures import Measure
-
-
-class DbsMeasure(DbsTemplate[Measure]):
-    dir_name = "measures"
-    display_name = "Measure"
-    _object_class = Measure
-
-    def get(self, name: str) -> Measure:
-        """Return a measure object.
-
-        Parameters
-        ----------
-        name : str
-            name of the measure to be returned
-
-        Returns
-        -------
-        Measure
-            measure object
-        """
-        # 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 summarize_objects(self) -> dict[str, list[Any]]:
-        """Return a dictionary with info on the measures that currently exist in the database.
-
-        Returns
-        -------
-        dict[str, Any]
-            Includes 'name', 'description', 'path' and 'last_modification_date' and 'geometry' info
-        """
-        measures = self._get_object_summary()
-        objects = [self.get(name) for name in measures["name"]]
-
-        geometries = []
-        for obj in objects:
-            # If polygon is used read the polygon file
-            if hasattr(obj, "polygon_file") and obj.polygon_file:
-                src_path = resolve_filepath(
-                    object_dir=self.dir_name,
-                    obj_name=obj.name,
-                    path=obj.polygon_file,
-                )
-                geometries.append(gpd.read_file(src_path))
-            # If aggregation area is used read the polygon from the 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()
-                ):
-                    raise ValueError(
-                        f"Aggregation area type {obj.aggregation_area_type} for measure {obj.name} does not exist."
-                    )
-                gdf = self._database.static.get_aggregation_areas()[
-                    obj.aggregation_area_type
-                ]
-                if obj.aggregation_area_name not in gdf["name"].to_numpy():
-                    raise ValueError(
-                        f"Aggregation area name {obj.aggregation_area_name} for measure {obj.name} does not exist."
-                    )
-                geometries.append(gdf.loc[gdf["name"] == obj.aggregation_area_name, :])
-            # Else assign a None value
-            else:
-                geometries.append(None)
-
-        measures["geometry"] = geometries
-        return measures
-
-    def check_higher_level_usage(self, name: str) -> list[str]:
-        """Check if a measure is used in a strategy.
-
-        Parameters
-        ----------
-        name : str
-            name of the measure to be checked
-
-        Returns
-        -------
-        list[str]
-            list of strategies that use the measure
-        """
-        # Get all the strategies
-        strategies = [
-            self._database.strategies.get(strategy)
-            for strategy in self._database.strategies.summarize_objects()["name"]
-        ]
-
-        # Check if measure is used in a strategy
-        used_in_strategy = [
-            strategy.name
-            for strategy in strategies
-            for measure in strategy.measures
-            if name == measure
-        ]
-        return used_in_strategy
+from pathlib import Path
+from typing import Any
+
+import geopandas as gpd
+
+from flood_adapt.dbs_classes.dbs_template import DbsTemplate
+from flood_adapt.misc.exceptions import DatabaseError
+from flood_adapt.misc.utils import resolve_filepath
+from flood_adapt.objects.measures.measure_factory import MeasureFactory
+from flood_adapt.objects.measures.measures import Measure
+
+
+class DbsMeasure(DbsTemplate[Measure]):
+    dir_name = "measures"
+    display_name = "Measure"
+    _object_class = Measure
+
+    def get(self, name: str) -> Measure:
+        """Return a measure object.
+
+        Parameters
+        ----------
+        name : str
+            name of the measure to be returned
+
+        Returns
+        -------
+        Measure
+            measure object
+        """
+        # 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 DatabaseError(f"{self.display_name}: '{name}' does not exist.")
+
+        # Load and return the object
+        return MeasureFactory.get_measure_object(full_path)
+
+    def summarize_objects(self) -> dict[str, list[Any]]:
+        """Return a dictionary with info on the measures that currently exist in the database.
+
+        Returns
+        -------
+        dict[str, Any]
+            Includes 'name', 'description', 'path' and 'last_modification_date' and 'geometry' info
+        """
+        measures = self._get_object_summary()
+        objects = [self.get(name) for name in measures["name"]]
+
+        geometries = []
+        for obj in objects:
+            # If polygon is used read the polygon file
+            if hasattr(obj, "polygon_file") and obj.polygon_file:
+                src_path = resolve_filepath(
+                    object_dir=self.dir_name,
+                    obj_name=obj.name,
+                    path=obj.polygon_file,
+                )
+                geometries.append(gpd.read_file(src_path))
+            # If aggregation area is used read the polygon from the 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()
+                ):
+                    raise DatabaseError(
+                        f"Aggregation area type {obj.aggregation_area_type} for measure {obj.name} does not exist."
+                    )
+                gdf = self._database.static.get_aggregation_areas()[
+                    obj.aggregation_area_type
+                ]
+                if obj.aggregation_area_name not in gdf["name"].to_numpy():
+                    raise DatabaseError(
+                        f"Aggregation area name {obj.aggregation_area_name} for measure {obj.name} does not exist."
+                    )
+                geometries.append(gdf.loc[gdf["name"] == obj.aggregation_area_name, :])
+            # Else assign a None value
+            else:
+                geometries.append(None)
+
+        measures["geometry"] = geometries
+        return measures
+
+    def check_higher_level_usage(self, name: str) -> list[str]:
+        """Check if a measure is used in a strategy.
+
+        Parameters
+        ----------
+        name : str
+            name of the measure to be checked
+
+        Returns
+        -------
+        list[str]
+            list of strategies that use the measure
+        """
+        # Get all the strategies
+        strategies = [
+            self._database.strategies.get(strategy)
+            for strategy in self._database.strategies.summarize_objects()["name"]
+        ]
+
+        # Check if measure is used in a strategy
+        used_in_strategy = [
+            strategy.name
+            for strategy in strategies
+            for measure in strategy.measures
+            if name == measure
+        ]
+        return used_in_strategy

flood_adapt/dbs_classes/dbs_projection.py

@@ -1,34 +1,34 @@
-from flood_adapt.dbs_classes.dbs_template import DbsTemplate
-from flood_adapt.objects.projections.projections import Projection
-
-
-class DbsProjection(DbsTemplate[Projection]):
-    dir_name = "projections"
-    display_name = "Projection"
-    _object_class = Projection
-
-    def check_higher_level_usage(self, name: str) -> list[str]:
-        """Check if a projection is used in a scenario.
-
-        Parameters
-        ----------
-        name : str
-            name of the projection to be checked
-
-        Returns
-        -------
-        list[str]
-            list of scenarios that use the projection
-        """
-        # Get all the scenarios
-        scenarios = [
-            self._database.scenarios.get(scn)
-            for scn in self._database.scenarios.summarize_objects()["name"]
-        ]
-
-        # Check if projection is used in a scenario
-        used_in_scenario = [
-            scenario.name for scenario in scenarios if name == scenario.projection
-        ]
-
-        return used_in_scenario
+from flood_adapt.dbs_classes.dbs_template import DbsTemplate
+from flood_adapt.objects.projections.projections import Projection
+
+
+class DbsProjection(DbsTemplate[Projection]):
+    dir_name = "projections"
+    display_name = "Projection"
+    _object_class = Projection
+
+    def check_higher_level_usage(self, name: str) -> list[str]:
+        """Check if a projection is used in a scenario.
+
+        Parameters
+        ----------
+        name : str
+            name of the projection to be checked
+
+        Returns
+        -------
+        list[str]
+            list of scenarios that use the projection
+        """
+        # Get all the scenarios
+        scenarios = [
+            self._database.scenarios.get(scn)
+            for scn in self._database.scenarios.summarize_objects()["name"]
+        ]
+
+        # Check if projection is used in a scenario
+        used_in_scenario = [
+            scenario.name for scenario in scenarios if name == scenario.projection
+        ]
+
+        return used_in_scenario