flood-adapt 0.3.0__py3-none-any.whl

flood_adapt/dbs_classes/dbs_template.py

@@ -0,0 +1,302 @@
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any, TypeVar
+
+import tomli_w
+
+from flood_adapt.dbs_classes.interface.database import IDatabase
+from flood_adapt.dbs_classes.interface.element import AbstractDatabaseElement
+from flood_adapt.objects.object_model import Object
+
+T_OBJECTMODEL = TypeVar("T_OBJECTMODEL", bound=Object)
+
+
+class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
+    display_name: str
+    dir_name: str
+    _object_class: type[T_OBJECTMODEL]
+
+    def __init__(self, database: IDatabase):
+        """Initialize any necessary attributes."""
+        self._database = database
+        self.input_path = database.input_path / self.dir_name
+        self.output_path = database.output_path / self.dir_name
+        self.standard_objects = []
+
+    def get(self, name: str) -> T_OBJECTMODEL:
+        """Return an object of the type of the database with the given name.
+
+        Parameters
+        ----------
+        name : str
+            name of the object to be returned
+
+        Returns
+        -------
+        Object
+            object of the type of the specified object model
+        """
+        # 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 self._object_class.load_file(full_path)
+
+    def list_objects(self) -> dict[str, list[Any]]:
+        """Return a dictionary with info on the objects that currently exist in the database.
+
+        Returns
+        -------
+        dict[str, list[Any]]
+            A dictionary that contains the keys: `name`, 'path', 'last_modification_date', 'description', 'objects'
+            Each key has a list of the corresponding values, where the index of the values corresponds to the same object.
+        """
+        # Check if all objects exist
+        object_list = self._get_object_list()
+
+        # Load all objects
+        objects = [self._object_class.load_file(path) for path in object_list["path"]]
+
+        # 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]
+        object_list["description"] = [obj.description for obj in objects]
+        object_list["objects"] = objects
+        return object_list
+
+    def copy(self, old_name: str, new_name: str, new_description: str):
+        """Copy (duplicate) an existing object, and give it a new name.
+
+        Parameters
+        ----------
+        old_name : str
+            name of the existing measure
+        new_name : str
+            name of the new measure
+        new_description : str
+            description of the new measure
+        """
+        copy_object = self.get(old_name)
+        copy_object.name = new_name
+        copy_object.description = new_description
+
+        # After changing the name and description, re-trigger the validators
+        copy_object.model_validate(copy_object)
+
+        # Checking whether the new name is already in use
+        self._validate_to_save(copy_object, overwrite=False)
+
+        # Write only the toml file
+        toml_path = self.input_path / new_name / f"{new_name}.toml"
+        toml_path.parent.mkdir(parents=True)
+        with open(toml_path, "wb") as f:
+            tomli_w.dump(copy_object.model_dump(exclude_none=True), f)
+
+        # Then copy all the accompanied files
+        src = self.input_path / old_name
+        dest = self.input_path / new_name
+
+        EXCLUDE = [".spw", ".toml"]
+        for file in src.glob("*"):
+            if file.suffix in EXCLUDE:
+                continue
+            if file.is_dir():
+                shutil.copytree(file, dest / file.name, dirs_exist_ok=True)
+            else:
+                shutil.copy2(file, dest / file.name)
+
+    def save(
+        self,
+        object_model: T_OBJECTMODEL,
+        overwrite: bool = False,
+    ):
+        """Save an object in the database and all associated files.
+
+        This saves the toml file and any additional files attached to the object.
+
+        Parameters
+        ----------
+        object_model : Object
+            object to be saved in the database
+        overwrite : bool, optional
+            whether to overwrite the object if it already exists in the
+            database, by default False
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        self._validate_to_save(object_model, overwrite=overwrite)
+
+        # If the folder doesnt exist yet, make the folder and save the object
+        if not (self.input_path / object_model.name).exists():
+            (self.input_path / object_model.name).mkdir()
+
+        # Save the object and any additional files
+        object_model.save(
+            self.input_path / object_model.name / f"{object_model.name}.toml",
+        )
+
+    def edit(self, object_model: T_OBJECTMODEL):
+        """Edit an already existing object in the database.
+
+        Parameters
+        ----------
+        object_model : Object
+            object to be edited in the database
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        # Check if the object exists
+        if object_model.name not in self.list_objects()["name"]:
+            raise ValueError(
+                f"{self.display_name}: '{object_model.name}' does not exist. You cannot edit an {self.display_name.lower()} that does not exist."
+            )
+
+        # Check if it is possible to delete the object by saving with overwrite. This then
+        # also covers checking whether the object is a standard object, is already used in
+        # a higher level object. If any of these are the case, it cannot be deleted.
+        self.save(object_model, overwrite=True)
+
+    def delete(self, name: str, toml_only: bool = False):
+        """Delete an already existing object in the database.
+
+        Parameters
+        ----------
+        name : str
+            name of the object 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 object to be deleted is already in use.
+        """
+        # Check if the object is a standard object. If it is, raise an error
+        if self._check_standard_objects(name):
+            raise ValueError(
+                f"'{name}' cannot be deleted/modified since it is a standard {self.display_name}."
+            )
+
+        # Check if object is used in a higher level object. If it is, raise an error
+        if used_in := self.check_higher_level_usage(name):
+            raise ValueError(
+                f"{self.display_name}: '{name}' cannot be deleted/modified since it is already used in: {', '.join(used_in)}"
+            )
+
+        # Once all checks are passed, delete the object
+        toml_path = self.input_path / name / f"{name}.toml"
+        if toml_only:
+            # Only delete the toml file
+            toml_path.unlink(missing_ok=True)
+            # If the folder is empty, delete the folder
+            if not list(toml_path.parent.iterdir()):
+                toml_path.parent.rmdir()
+        else:
+            # Delete the entire folder
+            shutil.rmtree(toml_path.parent, ignore_errors=True)
+            if (self.output_path / name).exists():
+                shutil.rmtree(self.output_path / name, ignore_errors=True)
+
+    def _check_standard_objects(self, name: str) -> bool:
+        """Check if an object is a standard object.
+
+        Parameters
+        ----------
+        name : str
+            name of the object to be checked
+
+        Returns
+        -------
+        bool
+            True if the object is a standard object, False otherwise
+        """
+        # If this function is not implemented for the object type, it cannot be a standard object.
+        # By default, it is not a standard object.
+        return False
+
+    def check_higher_level_usage(self, name: str) -> list[str]:
+        """Check if an object is used in a higher level object.
+
+        Parameters
+        ----------
+        name : str
+            name of the object to be checked
+
+        Returns
+        -------
+        list[str]
+            list of higher level objects that use the object
+        """
+        # If this function is not implemented for the object type, it cannot be used in a higher
+        # level object. By default, return an empty list
+        return []
+
+    def _get_object_list(self) -> dict[str, list[Any]]:
+        """Get a dictionary with all the toml paths and last modification dates that exist in the database of the given object_type.
+
+        Returns
+        -------
+        dict[str, Any]
+            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.
+        # In any case, we should not list it in the database
+        directories = [
+            dir
+            for dir in self.input_path.iterdir()
+            if (dir / f"{dir.name}.toml").is_file()
+        ]
+        paths = [Path(dir / f"{dir.name}.toml") for dir in directories]
+        names = [dir.name for dir in directories]
+        last_modification_date = [
+            datetime.fromtimestamp(file.stat().st_mtime) for file in paths
+        ]
+
+        objects = {
+            "name": names,
+            "path": paths,
+            "last_modification_date": last_modification_date,
+        }
+
+        return objects
+
+    def _validate_to_save(self, object_model: T_OBJECTMODEL, overwrite: bool) -> None:
+        """Validate if the object can be saved.
+
+        Parameters
+        ----------
+        object_model : Object
+            object to be validated
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        # Check if the object exists
+        if object_model.name in self.list_objects()["name"]:
+            raise ValueError(
+                f"{self.display_name}: '{object_model.name}' already exists. Choose a different name."
+            )
+        object_exists = object_model.name in self.list_objects()["name"]
+
+        # If you want to overwrite the object, and the object already exists, first delete it. If it exists and you
+        # don't want to overwrite, raise an error.
+        if overwrite and object_exists:
+            self.delete(object_model.name, toml_only=True)
+        elif not overwrite and object_exists:
+            raise ValueError(
+                f"'{object_model.name}' name is already used by another {self.display_name.lower()}. Choose a different name"
+            )

flood_adapt/dbs_classes/interface/database.py

@@ -0,0 +1,147 @@
+import os
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Optional, Union
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+from cht_cyclones.tropical_cyclone import TropicalCyclone
+
+from flood_adapt.config.site import Site
+from flood_adapt.dbs_classes.interface.element import AbstractDatabaseElement
+from flood_adapt.dbs_classes.interface.static import IDbsStatic
+from flood_adapt.objects.benefits.benefits import Benefit
+from flood_adapt.objects.events.events import Event
+
+
+class IDatabase(ABC):
+    base_path: Path
+    input_path: Path
+    output_path: Path
+    static_path: Path
+
+    @property
+    @abstractmethod
+    def site(self) -> Site: ...
+
+    @property
+    @abstractmethod
+    def static(self) -> IDbsStatic: ...
+
+    @property
+    @abstractmethod
+    def events(self) -> AbstractDatabaseElement: ...
+
+    @property
+    @abstractmethod
+    def scenarios(self) -> AbstractDatabaseElement: ...
+
+    @property
+    @abstractmethod
+    def strategies(self) -> AbstractDatabaseElement: ...
+
+    @property
+    @abstractmethod
+    def measures(self) -> AbstractDatabaseElement: ...
+
+    @property
+    @abstractmethod
+    def projections(self) -> AbstractDatabaseElement: ...
+
+    @property
+    @abstractmethod
+    def benefits(self) -> AbstractDatabaseElement: ...
+
+    @abstractmethod
+    def __init__(
+        self, database_path: Union[str, os.PathLike], site_name: str
+    ) -> None: ...
+
+    @abstractmethod
+    def interp_slr(self, slr_scenario: str, year: float) -> float:
+        pass
+
+    @abstractmethod
+    def plot_slr_scenarios(self) -> str:
+        pass
+
+    @abstractmethod
+    def write_to_csv(self, name: str, event: Event, df: pd.DataFrame) -> None:
+        pass
+
+    @abstractmethod
+    def write_cyc(self, event: Event, track: TropicalCyclone) -> None:
+        pass
+
+    @abstractmethod
+    def check_benefit_scenarios(self, benefit: Benefit) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def create_benefit_scenarios(self, benefit: Benefit) -> None:
+        pass
+
+    @abstractmethod
+    def run_benefit(self, benefit_name: Union[str, list[str]]) -> None:
+        pass
+
+    @abstractmethod
+    def update(self) -> None:
+        pass
+
+    @abstractmethod
+    def get_outputs(self) -> dict[str, Any]:
+        pass
+
+    @abstractmethod
+    def get_topobathy_path(self) -> str:
+        pass
+
+    @abstractmethod
+    def get_index_path(self) -> str:
+        pass
+
+    @abstractmethod
+    def get_depth_conversion(self) -> float:
+        pass
+
+    @abstractmethod
+    def get_max_water_level(
+        self, scenario_name: str, return_period: Optional[int] = None
+    ) -> np.ndarray:
+        pass
+
+    @abstractmethod
+    def get_building_footprints(self, scenario_name: str) -> gpd.GeoDataFrame:
+        pass
+
+    @abstractmethod
+    def get_roads(self, scenario_name: str) -> gpd.GeoDataFrame:
+        pass
+
+    @abstractmethod
+    def get_aggregation(self, scenario_name: str) -> dict[str, gpd.GeoDataFrame]:
+        pass
+
+    @abstractmethod
+    def get_aggregation_benefits(
+        self, benefit_name: str
+    ) -> dict[str, gpd.GeoDataFrame]:
+        pass
+
+    @abstractmethod
+    def get_object_list(self, object_type: str) -> dict[str, Any]:
+        pass
+
+    @abstractmethod
+    def has_run_hazard(self, scenario_name: str) -> None:
+        pass
+
+    @abstractmethod
+    def run_scenario(self, scenario_name: Union[str, list[str]]) -> None:
+        pass
+
+    @abstractmethod
+    def cleanup(self) -> None:
+        pass

flood_adapt/dbs_classes/interface/element.py

@@ -0,0 +1,137 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Generic, TypeVar
+
+from flood_adapt.objects.object_model import Object
+
+T_OBJECT_MODEL = TypeVar("T_OBJECT_MODEL", bound=Object)
+
+
+class AbstractDatabaseElement(ABC, Generic[T_OBJECT_MODEL]):
+    input_path: Path
+    output_path: Path
+
+    @abstractmethod
+    def __init__(self):
+        """Abstract class for database elements."""
+        pass
+
+    @abstractmethod
+    def get(self, name: str) -> T_OBJECT_MODEL:
+        """Return the object of the type of the database with the given name.
+
+        Parameters
+        ----------
+        name : str
+            name of the object to be returned
+
+        Returns
+        -------
+        IObject
+            object of the type of the specified object model
+        """
+        pass
+
+    @abstractmethod
+    def list_objects(self) -> dict[str, list[Any]]:
+        """Return a dictionary with info on the objects that currently exist in the database.
+
+        Returns
+        -------
+        dict[str, Any]
+            Includes 'name', 'description', 'path' and 'last_modification_date' info, as well as the objects themselves
+        """
+        pass
+
+    @abstractmethod
+    def copy(self, old_name: str, new_name: str, new_description: str):
+        """Copy (duplicate) an existing object, and give it a new name.
+
+        Parameters
+        ----------
+        old_name : str
+            name of the existing measure
+        new_name : str
+            name of the new measure
+        new_description : str
+            description of the new measure
+        """
+        pass
+
+    @abstractmethod
+    def save(
+        self,
+        object_model: T_OBJECT_MODEL,
+        overwrite: bool = False,
+    ):
+        """Save an object in the database.
+
+        This only saves the toml file. If the object also contains a geojson file, this should be saved separately.
+
+        Parameters
+        ----------
+        object_model : Object
+            object to be saved in the database
+        overwrite : bool, optional
+            whether to overwrite the object if it already exists in the
+            database, by default False
+        toml_only : bool, optional
+            whether to only save the toml file or all associated data. By default, save everything
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        pass
+
+    @abstractmethod
+    def edit(self, object_model: T_OBJECT_MODEL):
+        """Edits an already existing object in the database.
+
+        Parameters
+        ----------
+        object : IObject
+            object to be edited in the database
+
+        Raises
+        ------
+        ValueError
+            Raise error if name is already in use.
+        """
+        pass
+
+    @abstractmethod
+    def delete(self, name: str, toml_only: bool = False):
+        """Delete an already existing object in the database.
+
+        Parameters
+        ----------
+        name : str
+            name of the object 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 object to be deleted is already in use.
+        """
+        pass
+
+    @abstractmethod
+    def check_higher_level_usage(self, name: str) -> list[str]:
+        """Check if an object is used in a higher level object.
+
+        Parameters
+        ----------
+        name : str
+            name of the object to be checked
+
+        Returns
+        -------
+        list[str]
+            list of higher level objects that use the object
+        """
+        pass

flood_adapt/dbs_classes/interface/static.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Union
+
+import geopandas as gpd
+import pandas as pd
+from cht_cyclones.cyclone_track_database import CycloneTrackDatabase
+
+from flood_adapt.adapter.sfincs_adapter import SfincsAdapter
+
+
+class IDbsStatic(ABC):
+    @abstractmethod
+    def get_aggregation_areas(self) -> dict: ...
+
+    @abstractmethod
+    def get_model_boundary(self) -> gpd.GeoDataFrame: ...
+
+    @abstractmethod
+    def get_model_grid(self): ...
+
+    @abstractmethod
+    def get_obs_points(self) -> gpd.GeoDataFrame: ...
+
+    @abstractmethod
+    def get_static_map(self, path: Union[str, Path]) -> gpd.GeoDataFrame: ...
+
+    @abstractmethod
+    def get_slr_scn_names(self) -> list: ...
+
+    @abstractmethod
+    def get_green_infra_table(self, measure_type: str) -> pd.DataFrame: ...
+
+    @abstractmethod
+    def get_buildings(self) -> gpd.GeoDataFrame: ...
+
+    @abstractmethod
+    def get_property_types(self) -> list: ...
+
+    @abstractmethod
+    def get_overland_sfincs_model(self) -> SfincsAdapter: ...
+
+    @abstractmethod
+    def get_offshore_sfincs_model(self) -> SfincsAdapter: ...
+
+    @abstractmethod
+    def get_cyclone_track_database(self) -> CycloneTrackDatabase: ...