flood-adapt 0.3.0__py3-none-any.whl

flood_adapt/dbs_classes/dbs_benefit.py

@@ -0,0 +1,97 @@
+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 edit(self, benefit: Benefit):
+        """Edits an already existing benefit in the database.
+
+        Parameters
+        ----------
+        benefit : Benefit
+            benefit to be edited in the database
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        # Check if it is possible to edit the benefit.
+        super().edit(benefit)
+
+        # Delete output if edited
+        output_path = self.output_path / benefit.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

@@ -0,0 +1,91 @@
+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
+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 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.
+
+        Parameters
+        ----------
+        name : str
+            name of the event to be checked
+
+        Returns
+        -------
+        bool
+            True if the event is a standard event, False otherwise
+        """
+        # Check if event is a standard event
+        if self._database.site.standard_objects:
+            if self._database.site.standard_objects.events:
+                if name in self._database.site.standard_objects.events:
+                    return True
+        return False
+
+    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.list_objects()["objects"]
+
+        # 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

@@ -0,0 +1,103 @@
+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
+        """
+        measure_path = self.input_path / name / f"{name}.toml"
+        measure = MeasureFactory.get_measure_object(measure_path)
+        return measure
+
+    def list_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' info
+        """
+        measures = self._get_object_list()
+        objects = [MeasureFactory.get_measure_object(path) for path in measures["path"]]
+        measures["description"] = [obj.description for obj in objects]
+        measures["objects"] = objects
+
+        geometries = []
+        for path, obj in zip(measures["path"], objects):
+            # If polygon is used read the polygon file
+            if 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 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.list_objects()["objects"]
+
+        # 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

@@ -0,0 +1,52 @@
+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_standard_objects(self, name: str) -> bool:
+        """Check if a projection is a standard projection.
+
+        Parameters
+        ----------
+        name : str
+            name of the projection to be checked
+
+        Raises
+        ------
+        ValueError
+            Raise error if projection is a standard projection.
+        """
+        # Check if projection is a standard projection
+        if self._database.site.standard_objects:
+            if self._database.site.standard_objects.projections:
+                if name in self._database.site.standard_objects.projections:
+                    return True
+
+        return False
+
+    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.list_objects()["objects"]
+
+        # 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

flood_adapt/dbs_classes/dbs_scenario.py

@@ -0,0 +1,150 @@
+import shutil
+from typing import Any
+
+from flood_adapt.dbs_classes.dbs_template import DbsTemplate
+from flood_adapt.misc.utils import finished_file_exists
+from flood_adapt.objects.scenarios.scenarios import Scenario
+from flood_adapt.workflows.benefit_runner import BenefitRunner
+
+
+class DbsScenario(DbsTemplate[Scenario]):
+    dir_name = "scenarios"
+    display_name = "Scenario"
+    _object_class = Scenario
+
+    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
+        """
+        scenarios = super().list_objects()
+        objects = scenarios["objects"]
+        scenarios["Projection"] = [obj.projection for obj in objects]
+        scenarios["Event"] = [obj.event for obj in objects]
+        scenarios["Strategy"] = [obj.strategy for obj in objects]
+        scenarios["finished"] = [self.has_run_check(obj.name) for obj in objects]
+
+        return scenarios
+
+    def delete(self, name: str, toml_only: bool = False):
+        """Delete an already existing scenario in the database.
+
+        Parameters
+        ----------
+        name : str
+            name of the scenario to be deleted
+        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 scenario to be deleted is already in use.
+        """
+        # First delete the scenario
+        super().delete(name, toml_only)
+
+        # Then delete the results
+        if (self.output_path / name).exists():
+            shutil.rmtree(self.output_path / name, ignore_errors=False)
+
+    def edit(self, scenario: Scenario):
+        """Edits an already existing scenario in the database.
+
+        Parameters
+        ----------
+        scenario : Scenario
+            scenario to be edited in the database
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        # Check if it is possible to edit the scenario. This then also covers checking whether the
+        # scenario is already used in a higher level object. If this is the case, it cannot be edited.
+        super().edit(scenario)
+
+        # Delete output if edited
+        output_path = self.output_path / scenario.name
+        if output_path.exists():
+            shutil.rmtree(output_path, ignore_errors=True)
+
+    def check_higher_level_usage(self, name: str) -> list[str]:
+        """Check if a scenario is used in a benefit.
+
+        Parameters
+        ----------
+        name : str
+            name of the scenario to be checked
+
+        Returns
+        -------
+            list[str]
+                list of benefits that use the scenario
+        """
+        benefits = self._database.benefits.list_objects()["objects"]
+        used_in_benefit = []
+        for benefit in benefits:
+            runner = BenefitRunner(database=self._database, benefit=benefit)
+            scenarios = runner.check_scenarios()["scenario created"].to_list()
+            for scenario in scenarios:
+                if name == scenario:
+                    used_in_benefit.append(benefit.name)
+
+        return used_in_benefit
+
+    def equal_hazard_components(self, left: Scenario, right: Scenario) -> bool:
+        """Check if two scenarios have the same hazard components.
+
+        Parameters
+        ----------
+        left : Scenario
+            first scenario to be compared
+        right : Scenario
+            second scenario to be compared
+
+        Returns
+        -------
+            bool
+                True if the scenarios have the same hazard components, False otherwise
+        """
+        event_left = self._database.events.get(left.event)
+        event_right = self._database.events.get(right.event)
+        equal_events = event_left == event_right
+
+        left_projection = self._database.projections.get(left.projection)
+        right_projection = self._database.projections.get(right.projection)
+        equal_projection = (
+            left_projection.physical_projection == right_projection.physical_projection
+        )
+
+        left_strategy = self._database.strategies.get(
+            left.strategy
+        ).get_hazard_strategy()
+        right_strategy = self._database.strategies.get(
+            right.strategy
+        ).get_hazard_strategy()
+        equal_strategy = left_strategy == right_strategy
+
+        return equal_events and equal_projection and equal_strategy
+
+    def has_run_check(self, name: str) -> bool:
+        """Check if the scenario has been run.
+
+        Parameters
+        ----------
+        name : str
+            name of the scenario to be checked
+
+        Returns
+        -------
+            bool
+                True if the scenario has been run, False otherwise
+        """
+        results_path = self.output_path / name
+        return finished_file_exists(results_path)