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

flood_adapt/database_builder/database_builder.py

@@ -1,9 +1,12 @@
 import datetime
+import logging
 import math
 import os
 import shutil
+import time
 import warnings
 from enum import Enum
+from functools import wraps
 from pathlib import Path
 from typing import Optional, Union
 from urllib.request import urlretrieve
@@ -80,6 +83,29 @@ from flood_adapt.objects.projections.projections import (
 )
 from flood_adapt.objects.strategies.strategies import Strategy
 
+logger = FloodAdaptLogging.getLogger("DatabaseBuilder")
+
+
+def debug_timer(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        logger = FloodAdaptLogging.getLogger("DatabaseBuilder")  # No forced log level
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"Started '{func.__name__}'")
+            start_time = time.perf_counter()
+
+            result = func(*args, **kwargs)
+
+            end_time = time.perf_counter()
+            elapsed = end_time - start_time
+            logger.debug(f"Finished '{func.__name__}' in {elapsed:.4f} seconds")
+        else:
+            result = func(*args, **kwargs)
+
+        return result
+
+    return wrapper
+
 
 def path_check(str_path: str, config_path: Optional[Path] = None) -> str:
     """
@@ -243,32 +269,52 @@ class ConfigModel(BaseModel):
     ----------
     name : str
         The name of the site.
-    description : Optional[str], default ""
+    description : Optional[str], default None
         The description of the site.
     database_path : Optional[str], default None
         The path to the database where all the sites are located.
-    sfincs : str
-        The SFINCS model path.
-    sfincs_offshore : Optional[str], default None
-        The offshore SFINCS model path.
-    fiat : str
-        The FIAT model path.
     unit_system : UnitSystems
         The unit system.
-    gui : GuiModel
+    gui : GuiConfigModel
         The GUI model representing scaling values for the layers.
-    building_footprints : Optional[SpatialJoinModel], default None
-        The building footprints model.
-    slr_scenarios : Optional[SlrModelDef], default SlrModelDef()
-        The sea level rise model.
-    tide_gauge : Optional[TideGaugeConfigModel], default None
-        The tide gauge model.
+    infographics : Optional[bool], default True
+        Indicates if infographics are enabled.
+    fiat : str
+        The FIAT model path.
+    aggregation_areas : Optional[list[SpatialJoinModel]], default None
+        The list of aggregation area models.
+    building_footprints : Optional[SpatialJoinModel | FootprintsOptions], default FootprintsOptions.OSM
+        The building footprints model or OSM option.
+    fiat_buildings_name : Optional[str], default "buildings"
+        The name of the buildings geometry in the FIAT model.
+    fiat_roads_name : Optional[str], default "roads"
+        The name of the roads geometry in the FIAT model.
     bfe : Optional[SpatialJoinModel], default None
         The BFE model.
-    svi : Optional[SviModel], default None
+    svi : Optional[SviConfigModel], default None
         The SVI model.
-    road_width : Optional[float], default 2
+    road_width : Optional[float], default 5
         The road width in meters.
+    return_periods : list[int], default []
+        The list of return periods for risk calculations.
+    floodmap_type : Optional[FloodmapType], default None
+        The type of floodmap to use.
+    references : WaterlevelReferenceModel, default WaterlevelReferenceModel(...)
+        The water level reference model.
+    sfincs_overland : FloodModel
+        The overland SFINCS model.
+    sfincs_offshore : Optional[FloodModel], default None
+        The offshore SFINCS model.
+    dem : Optional[DemModel], default None
+        The DEM model.
+    excluded_datums : list[str], default []
+        List of datums to exclude from plotting.
+    slr_scenarios : Optional[SlrScenariosModel], default None
+        The sea level rise scenarios model.
+    scs : Optional[SCSModel], default None
+        The SCS model.
+    tide_gauge : Optional[TideGaugeConfigModel], default None
+        The tide gauge model.
     cyclones : Optional[bool], default True
         Indicates if cyclones are enabled.
     cyclone_basin : Optional[Basins], default None
@@ -277,8 +323,6 @@ class ConfigModel(BaseModel):
         The list of observation point models.
     probabilistic_set : Optional[str], default None
         The probabilistic set path.
-    infographics : Optional[bool], default True
-        Indicates if infographics are enabled.
     """
 
     # General
@@ -295,12 +339,13 @@ class ConfigModel(BaseModel):
     building_footprints: Optional[SpatialJoinModel | FootprintsOptions] = (
         FootprintsOptions.OSM
     )
-    fiat_buildings_name: Optional[str] = "buildings"
+    fiat_buildings_name: str | list[str] = "buildings"
     fiat_roads_name: Optional[str] = "roads"
     bfe: Optional[SpatialJoinModel] = None
     svi: Optional[SviConfigModel] = None
     road_width: Optional[float] = 5
     return_periods: list[int] = Field(default_factory=list)
+    floodmap_type: Optional[FloodmapType] = None
 
     # SFINCS
     references: WaterlevelReferenceModel = WaterlevelReferenceModel(
@@ -379,8 +424,6 @@ class ConfigModel(BaseModel):
 
 
 class DatabaseBuilder:
-    logger = FloodAdaptLogging.getLogger("DatabaseBuilder")
-
     _has_roads: bool = False
     _aggregation_areas: Optional[list] = None
     _probabilistic_set_name: Optional[str] = None
@@ -406,6 +449,7 @@ class DatabaseBuilder:
     def static_path(self) -> Path:
         return self.root / "static"
 
+    @debug_timer
     def build(self, overwrite: bool = False) -> None:
         # Check if database already exists
         if self.root.exists() and not overwrite:
@@ -423,9 +467,7 @@ class DatabaseBuilder:
         with FloodAdaptLogging.to_file(
             file_path=self.root.joinpath("database_builder.log")
         ):
-            self.logger.info(
-                f"Creating a FloodAdapt database in '{self.root.as_posix()}'"
-            )
+            logger.info(f"Creating a FloodAdapt database in '{self.root.as_posix()}'")
 
             # Make folder structure and read models
             self.setup()
@@ -441,8 +483,9 @@ class DatabaseBuilder:
             self.create_standard_objects()
 
             # Save log file
-            self.logger.info("FloodAdapt database creation finished!")
+            logger.info("FloodAdapt database creation finished!")
 
+    @debug_timer
     def setup(self) -> None:
         # Create the models
         self.make_folder_structure()
@@ -452,6 +495,7 @@ class DatabaseBuilder:
         self.read_template_sfincs_overland_model()
         self.read_template_sfincs_offshore_model()
 
+    @debug_timer
     def set_standard_objects(self):
         # Define name and create object
         self._no_measures_strategy_name = "no_measures"
@@ -467,14 +511,13 @@ class DatabaseBuilder:
         )
         return std_obj
 
+    @debug_timer
     def create_standard_objects(self):
         with modified_environ(
             DATABASE_ROOT=str(self.root.parent),
             DATABASE_NAME=self.root.name,
         ):
-            self.logger.info(
-                "Creating `no measures` strategy and `current` projection."
-            )
+            logger.info("Creating `no measures` strategy and `current` projection.")
             # Create database instance
             db = Database(self.root.parent, self.config.name)
             # Create no measures strategy
@@ -506,6 +549,7 @@ class DatabaseBuilder:
                     )
 
     ### TEMPLATE READERS ###
+    @debug_timer
     def read_template_fiat_model(self):
         user_provided = self._check_exists_and_absolute(self.config.fiat)
 
@@ -543,6 +587,7 @@ class DatabaseBuilder:
 
         self.fiat_model = in_db
 
+    @debug_timer
     def read_template_sfincs_overland_model(self):
         user_provided = self._check_exists_and_absolute(
             self.config.sfincs_overland.name
@@ -560,6 +605,7 @@ class DatabaseBuilder:
         in_db.read()
         self.sfincs_overland_model = in_db
 
+    @debug_timer
     def read_template_sfincs_offshore_model(self):
         if self.config.sfincs_offshore is None:
             self.sfincs_offshore_model = None
@@ -582,6 +628,7 @@ class DatabaseBuilder:
         self.sfincs_offshore_model = in_db
 
     ### FIAT ###
+    @debug_timer
     def create_fiat_model(self) -> FiatModel:
         fiat = FiatModel(
             config=self.create_fiat_config(),
@@ -590,17 +637,18 @@ class DatabaseBuilder:
         )
         return fiat
 
+    @debug_timer
     def create_risk_model(self) -> Optional[RiskModel]:
         # Check if return periods are provided
         if not self.config.return_periods:
             if self._probabilistic_set_name:
                 risk = RiskModel()
-                self.logger.warning(
+                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(
+                logger.warning(
                     "No return periods provided and no probabilistic set available. Risk calculations will not be performed."
                 )
                 return None
@@ -608,9 +656,10 @@ class DatabaseBuilder:
             risk = RiskModel(return_periods=self.config.return_periods)
         return risk
 
+    @debug_timer
     def create_benefit_config(self) -> Optional[BenefitsModel]:
         if self._probabilistic_set_name is None:
-            self.logger.warning(
+            logger.warning(
                 "No probabilistic set found in the config, benefits will not be available."
             )
             return None
@@ -621,14 +670,10 @@ class DatabaseBuilder:
             event_set=self._probabilistic_set_name,
         )
 
+    @debug_timer
     def create_fiat_config(self) -> FiatConfigModel:
         # Make sure only csv objects have geometries
-        for i, geoms in enumerate(self.fiat_model.exposure.exposure_geoms):
-            keep = geoms[_FIAT_COLUMNS.object_id].isin(
-                self.fiat_model.exposure.exposure_db[_FIAT_COLUMNS.object_id]
-            )
-            geoms = geoms[keep].reset_index(drop=True)
-            self.fiat_model.exposure.exposure_geoms[i] = geoms
+        self._delete_extra_geometries()
 
         footprints = self.create_footprints()
         if footprints is not None:
@@ -642,9 +687,16 @@ class DatabaseBuilder:
         self._aggregation_areas = self.create_aggregation_areas()
 
         roads_gpkg = self.create_roads()
-        non_building_names = []
-        if roads_gpkg is not None:
-            non_building_names.append("road")
+
+        # Get classes of non-building objects
+        non_buildings = ~self.fiat_model.exposure.exposure_db[
+            _FIAT_COLUMNS.object_id
+        ].isin(self._get_fiat_building_geoms()[_FIAT_COLUMNS.object_id])
+        non_building_names = list(
+            self.fiat_model.exposure.exposure_db[_FIAT_COLUMNS.primary_object_type][
+                non_buildings
+            ].unique()
+        )
 
         # Update elevations
         self.update_fiat_elevation()
@@ -676,11 +728,18 @@ class DatabaseBuilder:
                     self.fiat_model.config["exposure"]["geom"][key]
                 ).name
         self.fiat_model.config["output"]["geom"] = output_geom
+        # Make sure objects are ordered based on object id
+        self.fiat_model.exposure.exposure_db = (
+            self.fiat_model.exposure.exposure_db.sort_values(
+                by=[_FIAT_COLUMNS.object_id], ignore_index=True
+            )
+        )
         # Update FIAT model with the new config
         self.fiat_model.write()
 
         return config
 
+    @debug_timer
     def update_fiat_elevation(self):
         """
         Update the ground elevations of FIAT objects based on the SFINCS ground elevation map.
@@ -691,7 +750,7 @@ class DatabaseBuilder:
         dem_file = self._dem_path
         # TODO resolve issue with double geometries in hydromt-FIAT and use update_ground_elevation method instead
         # self.fiat_model.update_ground_elevation(dem_file, grnd_elev_unit="meters")
-        self.logger.info(
+        logger.info(
             "Updating FIAT objects ground elevations from SFINCS ground elevation map."
         )
         SFINCS_units = us.UnitfulLength(
@@ -701,88 +760,60 @@ class DatabaseBuilder:
         conversion_factor = SFINCS_units.convert(FIAT_units)
 
         if not math.isclose(conversion_factor, 1):
-            self.logger.info(
+            logger.info(
                 f"Ground elevation for FIAT objects is in '{FIAT_units}', while SFINCS ground elevation is in 'meters'. Values in the exposure csv will be converted by a factor of {conversion_factor}"
             )
 
         exposure = self.fiat_model.exposure.exposure_db
         dem = rxr.open_rasterio(dem_file)
-        # TODO make sure only fiat_model object changes take place!
-        if self.config.fiat_roads_name in self.fiat_model.exposure.geom_names:
-            roads = self.fiat_model.exposure.exposure_geoms[
-                self._get_fiat_road_index()
-            ].to_crs(dem.spatial_ref.crs_wkt)
-            roads["centroid"] = roads.geometry.centroid  # get centroids
-
-            x_points = xr.DataArray(roads["centroid"].x, dims="points")
-            y_points = xr.DataArray(roads["centroid"].y, dims="points")
-            roads["elev"] = (
-                dem.sel(x=x_points, y=y_points, band=1, method="nearest").to_numpy()
-                * conversion_factor
-            )
-
-            exposure.loc[
-                exposure[_FIAT_COLUMNS.primary_object_type] == "road",
-                _FIAT_COLUMNS.ground_floor_height,
-            ] = 0
-            exposure = exposure.merge(
-                roads[[_FIAT_COLUMNS.object_id, "elev"]],
-                on=_FIAT_COLUMNS.object_id,
-                how="left",
-            )
-            exposure.loc[
-                exposure[_FIAT_COLUMNS.primary_object_type] == "road",
-                _FIAT_COLUMNS.ground_elevation,
-            ] = exposure.loc[
-                exposure[_FIAT_COLUMNS.primary_object_type] == "road", "elev"
-            ]
-            del exposure["elev"]
-            self.fiat_model.exposure.exposure_db = exposure
-
-        buildings = self.fiat_model.exposure.exposure_geoms[
-            self._get_fiat_building_index()
-        ].to_crs(dem.spatial_ref.crs_wkt)
-        buildings["geometry"] = buildings.geometry.centroid
-        x_points = xr.DataArray(buildings["geometry"].x, dims="points")
-        y_points = xr.DataArray(buildings["geometry"].y, dims="points")
-        buildings["elev"] = (
+
+        gdf = self._get_fiat_gdf_full()
+        gdf["centroid"] = gdf.geometry.centroid
+        x_points = xr.DataArray(gdf["centroid"].x, dims="points")
+        y_points = xr.DataArray(gdf["centroid"].y, dims="points")
+        gdf["elev"] = (
             dem.sel(x=x_points, y=y_points, band=1, method="nearest").to_numpy()
             * conversion_factor
         )
+
         exposure = exposure.merge(
-            buildings[[_FIAT_COLUMNS.object_id, "elev"]],
+            gdf[[_FIAT_COLUMNS.object_id, "elev"]],
             on=_FIAT_COLUMNS.object_id,
             how="left",
         )
-        exposure.loc[
-            exposure[_FIAT_COLUMNS.primary_object_type] != "road",
-            _FIAT_COLUMNS.ground_elevation,
-        ] = exposure.loc[exposure[_FIAT_COLUMNS.primary_object_type] != "road", "elev"]
+        exposure[_FIAT_COLUMNS.ground_elevation] = exposure["elev"]
         del exposure["elev"]
 
+        self.fiat_model.exposure.exposure_db = exposure
+
     def read_damage_unit(self) -> str:
         if self.fiat_model.exposure.damage_unit is not None:
             return self.fiat_model.exposure.damage_unit
         else:
-            self.logger.warning(
+            logger.warning(
                 "Delft-FIAT model was missing damage units so '$' was assumed."
             )
             return "$"
 
+    @debug_timer
     def read_floodmap_type(self) -> FloodmapType:
-        # If there is at least on object that uses the area method, use water depths for FA calcs
-        if (
-            self.fiat_model.exposure.exposure_db[_FIAT_COLUMNS.extraction_method]
-            == "area"
-        ).any():
-            return FloodmapType.water_depth
+        if self.config.floodmap_type is not None:
+            return self.config.floodmap_type
         else:
-            return FloodmapType.water_level
+            # If there is at least on object that uses the area method, use water depths for FA calcs
+            if (
+                self.fiat_model.exposure.exposure_db[_FIAT_COLUMNS.extraction_method]
+                == "area"
+            ).any():
+                return FloodmapType.water_depth
+            else:
+                return FloodmapType.water_level
 
+    @debug_timer
     def create_roads(self) -> Optional[str]:
         # Make sure that FIAT roads are polygons
         if self.config.fiat_roads_name not in self.fiat_model.exposure.geom_names:
-            self.logger.warning(
+            logger.warning(
                 "Road objects are not available in the FIAT model and thus would not be available in FloodAdapt."
             )
             # TODO check how this naming of output geoms should become more explicit!
@@ -795,7 +826,7 @@ class DatabaseBuilder:
             _FIAT_COLUMNS.segment_length
             not in self.fiat_model.exposure.exposure_db.columns
         ):
-            self.logger.warning(
+            logger.warning(
                 f"'{_FIAT_COLUMNS.segment_length}' column not present in the FIAT exposure csv. Road impact infometrics cannot be produced."
             )
 
@@ -807,16 +838,18 @@ class DatabaseBuilder:
             )
             roads = roads.to_crs(self.fiat_model.exposure.crs)
             self.fiat_model.exposure.exposure_geoms[self._get_fiat_road_index()] = roads
-            self.logger.info(
+            logger.info(
                 f"FIAT road objects transformed from lines to polygons assuming a road width of {self.config.road_width} meters."
             )
 
         self._has_roads = True
         return f"{self.config.fiat_roads_name}.gpkg"
 
+    @debug_timer
     def create_new_developments(self) -> Optional[str]:
         return "new_development_area.gpkg"
 
+    @debug_timer
     def create_footprints(self) -> Optional[Path]:
         if isinstance(self.config.building_footprints, SpatialJoinModel):
             # Use the provided building footprints
@@ -824,7 +857,7 @@ class DatabaseBuilder:
                 self.config.building_footprints.file
             )
 
-            self.logger.info(
+            logger.info(
                 f"Using building footprints from {Path(building_footprints_file).as_posix()}."
             )
             # Spatially join buildings and map
@@ -835,7 +868,7 @@ class DatabaseBuilder:
             )
             return path
         elif self.config.building_footprints == FootprintsOptions.OSM:
-            self.logger.info(
+            logger.info(
                 "Building footprint data will be downloaded from Open Street Maps."
             )
             region = self.fiat_model.region
@@ -857,12 +890,10 @@ class DatabaseBuilder:
             return path
         # Then check if geometries are already footprints
         elif isinstance(
-            self.fiat_model.exposure.exposure_geoms[
-                self._get_fiat_building_index()
-            ].geometry.iloc[0],
+            self._get_fiat_building_geoms().geometry.iloc[0],
             (Polygon, MultiPolygon),
         ):
-            self.logger.info(
+            logger.info(
                 "Building footprints are already available in the FIAT model geometry files."
             )
             return None
@@ -885,21 +916,20 @@ class DatabaseBuilder:
                     f"While 'BF_FID' column exists, building footprints file {footprints_path} not found."
                 )
 
-            self.logger.info(
-                f"Using the building footprints located at {footprints_path}."
-            )
+            logger.info(f"Using the building footprints located at {footprints_path}.")
             return footprints_path.relative_to(self.static_path)
 
         # Other methods
         else:
-            self.logger.warning(
+            logger.warning(
                 "No building footprints are available. Buildings will be plotted with a default shape in FloodAdapt."
             )
             return None
 
+    @debug_timer
     def create_bfe(self) -> Optional[BFEModel]:
         if self.config.bfe is None:
-            self.logger.warning(
+            logger.warning(
                 "No base flood elevation provided. Elevating building relative to base flood elevation will not be possible in FloodAdapt."
             )
             return None
@@ -907,13 +937,13 @@ class DatabaseBuilder:
         # TODO can we use hydromt-FIAT?
         bfe_file = self._check_exists_and_absolute(self.config.bfe.file)
 
-        self.logger.info(
+        logger.info(
             f"Using map from {Path(bfe_file).as_posix()} as base flood elevation."
         )
 
         # Spatially join buildings and map
         buildings_joined, bfe = self.spatial_join(
-            self.fiat_model.exposure.exposure_geoms[self._get_fiat_building_index()],
+            self._get_fiat_building_geoms(),
             bfe_file,
             self.config.bfe.field_name,
         )
@@ -940,6 +970,7 @@ class DatabaseBuilder:
             field_name=self.config.bfe.field_name,
         )
 
+    @debug_timer
     def create_aggregation_areas(self) -> list[AggregationModel]:
         # TODO split this to 3 methods?
         aggregation_areas = []
@@ -982,7 +1013,7 @@ class DatabaseBuilder:
                 )
                 aggregation_areas.append(aggr)
 
-                self.logger.info(
+                logger.info(
                     f"Aggregation areas: {aggr.name} from the FIAT model are going to be used."
                 )
 
@@ -1002,10 +1033,9 @@ class DatabaseBuilder:
                     )
                 # Do spatial join of FIAT objects and aggregation areas
                 exposure_csv = self.fiat_model.exposure.exposure_db
-                buildings_joined, aggr_areas = self.spatial_join(
-                    objects=self.fiat_model.exposure.exposure_geoms[
-                        self._get_fiat_building_index()
-                    ],
+                gdf = self._get_fiat_gdf_full()
+                gdf_joined, aggr_areas = self.spatial_join(
+                    objects=gdf[[_FIAT_COLUMNS.object_id, "geometry"]],
                     layer=str(self._check_exists_and_absolute(aggr.file)),
                     field_name=aggr.field_name,
                     rename=_FIAT_COLUMNS.aggregation_label.format(name=aggr_name),
@@ -1016,7 +1046,7 @@ class DatabaseBuilder:
                 aggr_path.parent.mkdir(parents=True, exist_ok=True)
                 aggr_areas.to_file(aggr_path)
                 exposure_csv = exposure_csv.merge(
-                    buildings_joined, on=_FIAT_COLUMNS.object_id, how="left"
+                    gdf_joined, on=_FIAT_COLUMNS.object_id, how="left"
                 )
                 self.fiat_model.exposure.exposure_db = exposure_csv
                 # Update spatial joins in FIAT model
@@ -1067,31 +1097,29 @@ class DatabaseBuilder:
             aggregation_areas.append(aggr)
 
             # Add column in FIAT
-            buildings_joined, _ = self.spatial_join(
-                objects=self.fiat_model.exposure.exposure_geoms[
-                    self._get_fiat_building_index()
-                ],
+            gdf = self._get_fiat_gdf_full()
+            gdf_joined, aggr_areas = self.spatial_join(
+                objects=gdf[[_FIAT_COLUMNS.object_id, "geometry"]],
                 layer=region,
                 field_name="aggr_id",
                 rename=_FIAT_COLUMNS.aggregation_label.format(name="region"),
             )
             exposure_csv = exposure_csv.merge(
-                buildings_joined, on=_FIAT_COLUMNS.object_id, how="left"
+                gdf_joined, on=_FIAT_COLUMNS.object_id, how="left"
             )
             self.fiat_model.exposure.exposure_db = exposure_csv
-            self.logger.warning(
+            logger.warning(
                 "No aggregation areas were available in the FIAT model and none were provided in the config file. The region file will be used as a mock aggregation area."
             )
         return aggregation_areas
 
+    @debug_timer
     def create_svi(self) -> Optional[SVIModel]:
         if self.config.svi:
             svi_file = self._check_exists_and_absolute(self.config.svi.file)
             exposure_csv = self.fiat_model.exposure.exposure_db
             buildings_joined, svi = self.spatial_join(
-                self.fiat_model.exposure.exposure_geoms[
-                    self._get_fiat_building_index()
-                ],
+                self._get_fiat_building_geoms(),
                 svi_file,
                 self.config.svi.field_name,
                 rename="SVI",
@@ -1099,12 +1127,12 @@ class DatabaseBuilder:
             )
             # Add column to exposure
             if "SVI" in exposure_csv.columns:
-                self.logger.info(
+                logger.info(
                     f"'SVI' column in the FIAT exposure csv will be replaced by {svi_file.as_posix()}."
                 )
                 del exposure_csv["SVI"]
             else:
-                self.logger.info(
+                logger.info(
                     f"'SVI' column in the FIAT exposure csv will be filled by {svi_file.as_posix()}."
                 )
             exposure_csv = exposure_csv.merge(
@@ -1116,7 +1144,7 @@ class DatabaseBuilder:
             svi_path = self.static_path / "templates" / "fiat" / "svi" / "svi.gpkg"
             svi_path.parent.mkdir(parents=True, exist_ok=True)
             svi.to_file(svi_path)
-            self.logger.info(
+            logger.info(
                 f"An SVI map can be shown in FloodAdapt GUI using '{self.config.svi.field_name}' column from {svi_file.as_posix()}"
             )
 
@@ -1125,19 +1153,17 @@ class DatabaseBuilder:
                 field_name="SVI",
             )
         elif "SVI" in self.fiat_model.exposure.exposure_db.columns:
-            self.logger.info(
+            logger.info(
                 "'SVI' column present in the FIAT exposure csv. Vulnerability type infometrics can be produced."
             )
             add_attrs = self.fiat_model.spatial_joins["additional_attributes"]
             if "SVI" not in [attr["name"] for attr in add_attrs]:
-                self.logger.warning(
-                    "No SVI map found to display in the FloodAdapt GUI!"
-                )
+                logger.warning("No SVI map found to display in the FloodAdapt GUI!")
 
             ind = [attr["name"] for attr in add_attrs].index("SVI")
             svi = add_attrs[ind]
             svi_path = self.static_path / "templates" / "fiat" / svi["file"]
-            self.logger.info(
+            logger.info(
                 f"An SVI map can be shown in FloodAdapt GUI using '{svi['field_name']}' column from {svi['file']}"
             )
             # Save site attributes
@@ -1147,12 +1173,13 @@ class DatabaseBuilder:
             )
 
         else:
-            self.logger.warning(
+            logger.warning(
                 "'SVI' column not present in the FIAT exposure csv. Vulnerability type infometrics cannot be produced."
             )
             return None
 
     ### SFINCS ###
+    @debug_timer
     def create_sfincs_config(self) -> SfincsModel:
         # call these functions before others to make sure water level references are updated
         config = self.create_sfincs_model_config()
@@ -1172,9 +1199,10 @@ class DatabaseBuilder:
 
         return sfincs
 
+    @debug_timer
     def create_cyclone_track_database(self) -> Optional[CycloneTrackDatabaseModel]:
         if not self.config.cyclones or not self.config.sfincs_offshore:
-            self.logger.warning("No cyclones will be available in the database.")
+            logger.warning("No cyclones will be available in the database.")
             return None
 
         if self.config.cyclone_basin:
@@ -1184,7 +1212,7 @@ class DatabaseBuilder:
 
         name = f"IBTrACS.{basin.value}.v04r01.nc"
         url = f"https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r01/access/netcdf/{name}"
-        self.logger.info(f"Downloading cyclone track database from {url}")
+        logger.info(f"Downloading cyclone track database from {url}")
         fn = Path(self.root) / "static" / "cyclone_track_database" / name
         fn.parent.mkdir(parents=True, exist_ok=True)
 
@@ -1195,6 +1223,7 @@ class DatabaseBuilder:
 
         return CycloneTrackDatabaseModel(file=name)
 
+    @debug_timer
     def create_scs_model(self) -> Optional[SCSModel]:
         if self.config.scs is None:
             return None
@@ -1205,11 +1234,12 @@ class DatabaseBuilder:
 
         return SCSModel(file=scs_file.name, type=self.config.scs.type)
 
+    @debug_timer
     def create_dem_model(self) -> DemModel:
         if self.config.dem:
             subgrid_sfincs = Path(self.config.dem.filename)
         else:
-            self.logger.warning(
+            logger.warning(
                 "No subgrid depth geotiff file provided in the config file. Using the one from the SFINCS model."
             )
             subgrid_sfincs = (
@@ -1227,7 +1257,7 @@ class DatabaseBuilder:
             shutil.move(tiles_sfincs, fa_tiles_path)
             if (fa_tiles_path / "index").exists():
                 os.rename(fa_tiles_path / "index", fa_tiles_path / "indices")
-            self.logger.info(
+            logger.info(
                 "Tiles were already available in the SFINCS model and will directly be used in FloodAdapt."
             )
         else:
@@ -1239,7 +1269,7 @@ class DatabaseBuilder:
                 zoom_range=[0, 13],
                 fmt="png",
             )
-            self.logger.info(
+            logger.info(
                 f"Tiles were created using the {subgrid_sfincs.as_posix()} as the elevation map."
             )
 
@@ -1249,6 +1279,7 @@ class DatabaseBuilder:
             filename=fa_subgrid_path.name, units=us.UnitTypesLength.meters
         )  # always in meters
 
+    @debug_timer
     def create_sfincs_model_config(self) -> SfincsConfigModel:
         config = SfincsConfigModel(
             csname=self.sfincs_overland_model.crs.name,
@@ -1263,6 +1294,7 @@ class DatabaseBuilder:
 
         return config
 
+    @debug_timer
     def create_slr(self) -> Optional[SlrScenariosModel]:
         if self.config.slr_scenarios is None:
             return None
@@ -1280,17 +1312,19 @@ class DatabaseBuilder:
             relative_to_year=self.config.slr_scenarios.relative_to_year,
         )
 
+    @debug_timer
     def create_observation_points(self) -> Union[list[ObsPointModel], None]:
         if self.config.obs_point is None:
             return None
 
-        self.logger.info("Observation points were provided in the config file.")
+        logger.info("Observation points were provided in the config file.")
         return self.config.obs_point
 
+    @debug_timer
     def create_rivers(self) -> list[RiverModel]:
         src_file = Path(self.sfincs_overland_model.root) / "sfincs.src"
         if not src_file.exists():
-            self.logger.warning("No rivers found in the SFINCS model.")
+            logger.warning("No rivers found in the SFINCS model.")
             return []
 
         df = pd.read_csv(src_file, delim_whitespace=True, header=None, names=["x", "y"])
@@ -1310,7 +1344,7 @@ class DatabaseBuilder:
                 )
             else:
                 discharge = 0
-                self.logger.warning(
+                logger.warning(
                     f"No river discharge conditions were found in the SFINCS model for river {idx}. A default value of 0 will be used."
                 )
 
@@ -1324,18 +1358,19 @@ class DatabaseBuilder:
             )
             rivers.append(river)
 
-        self.logger.info(
+        logger.info(
             f"{len(river_locs)} river(s) were identified from the SFINCS model and will be available in FloodAdapt for discharge input."
         )
 
         return rivers
 
+    @debug_timer
     def create_tide_gauge(self) -> Optional[TideGauge]:
         if self.config.tide_gauge is None:
-            self.logger.warning(
+            logger.warning(
                 "Tide gauge information not provided. Historical events will not have an option to use gauged data in FloodAdapt!"
             )
-            self.logger.warning(
+            logger.warning(
                 "No water level references were found. It is assumed that MSL is equal to the datum used in the SFINCS overland model. You can provide these values with the tide_gauge.ref attribute in the site.toml."
             )
             return None
@@ -1346,7 +1381,7 @@ class DatabaseBuilder:
                     "Tide gauge file needs to be provided when 'file' is selected as the source."
                 )
             if self.config.tide_gauge.ref is None:
-                self.logger.warning(
+                logger.warning(
                     "Tide gauge reference not provided. MSL is assumed as the reference of the water levels in the file."
                 )
                 self.config.tide_gauge.ref = "MSL"
@@ -1360,7 +1395,7 @@ class DatabaseBuilder:
             shutil.copyfile(self.config.tide_gauge.file, db_file_path)
 
             rel_db_path = Path(db_file_path.relative_to(self.static_path))
-            self.logger.warning(
+            logger.warning(
                 f"Tide gauge from file {rel_db_path} assumed to be in {self.unit_system.default_length_units}!"
             )
             tide_gauge = TideGauge(
@@ -1387,12 +1422,12 @@ class DatabaseBuilder:
 
             if self.config.tide_gauge.id is None:
                 station_id = self._get_closest_station()
-                self.logger.info(
+                logger.info(
                     "The closest NOAA tide gauge station to the site will be searched."
                 )
             else:
                 station_id = self.config.tide_gauge.id
-                self.logger.info(
+                logger.info(
                     f"The NOAA tide gauge station with the provided ID {station_id} will be used."
                 )
             station = self._get_station_metadata(station_id=station_id, ref=ref)
@@ -1448,11 +1483,12 @@ class DatabaseBuilder:
                     self.water_level_references.datums.append(wl_info)
             return tide_gauge
         else:
-            self.logger.warning(
+            logger.warning(
                 f"Tide gauge source not recognized: {self.config.tide_gauge.source}. Historical events will not have an option to use gauged data in FloodAdapt!"
             )
             return None
 
+    @debug_timer
     def create_offshore_model(self) -> Optional[FloodModel]:
         if self.sfincs_offshore_model is None:
             return None
@@ -1477,7 +1513,7 @@ class DatabaseBuilder:
             index=False,
             header=False,
         )
-        self.logger.info(
+        logger.info(
             "Output points of the offshore SFINCS model were reconfigured to the boundary points of the overland SFINCS model."
         )
 
@@ -1487,6 +1523,7 @@ class DatabaseBuilder:
             vertical_offset=self.config.sfincs_offshore.vertical_offset,
         )
 
+    @debug_timer
     def create_overland_model(self) -> FloodModel:
         return FloodModel(
             name="overland",
@@ -1494,6 +1531,7 @@ class DatabaseBuilder:
         )
 
     ### SITE ###
+    @debug_timer
     def create_site_config(self) -> Site:
         """Create the site configuration for the FloodAdapt model.
 
@@ -1533,18 +1571,16 @@ class DatabaseBuilder:
         )
         return config
 
+    @debug_timer
     def read_location(self) -> tuple[float, float]:
         # Get center of area of interest
         if not self.fiat_model.region.empty:
             center = self.fiat_model.region.dissolve().centroid.to_crs(4326)[0]
         else:
-            center = (
-                self.fiat_model.exposure.exposure_geoms[self._get_fiat_building_index()]
-                .dissolve()
-                .centroid.to_crs(4326)[0]
-            )
+            center = self._get_fiat_building_geoms().dissolve().centroid.to_crs(4326)[0]
         return center.x, center.y
 
+    @debug_timer
     def create_gui_config(self) -> GuiModel:
         gui = GuiModel(
             units=self.unit_system,
@@ -1555,6 +1591,7 @@ class DatabaseBuilder:
 
         return gui
 
+    @debug_timer
     def create_default_units(self) -> GuiUnitModel:
         if self.config.unit_system == UnitSystems.imperial:
             return GuiUnitModel.imperial()
@@ -1565,6 +1602,7 @@ class DatabaseBuilder:
                 f"Unit system {self.config.unit_system} not recognized. Please choose 'imperial' or 'metric'."
             )
 
+    @debug_timer
     def create_visualization_layers(self) -> VisualizationLayers:
         visualization_layers = VisualizationLayers()
         if self._svi is not None:
@@ -1578,6 +1616,7 @@ class DatabaseBuilder:
             )
         return visualization_layers
 
+    @debug_timer
     def create_output_layers_config(self) -> OutputLayers:
         # Read default colors from template
         fd_max = self.config.gui.max_flood_depth
@@ -1633,6 +1672,7 @@ class DatabaseBuilder:
         )
         return output_layers
 
+    @debug_timer
     def create_hazard_plotting_config(self) -> PlottingModel:
         datum_names = [datum.name for datum in self.water_level_references.datums]
         if "MHHW" in datum_names:
@@ -1640,20 +1680,20 @@ class DatabaseBuilder:
                 self.water_level_references.get_datum("MHHW").height
                 - self.water_level_references.get_datum("MSL").height
             )
-            self.logger.info(
+            logger.info(
                 f"The default tidal amplitude in the GUI will be {amplitude.transform(self.unit_system.default_length_units)}, calculated as the difference between MHHW and MSL from the tide gauge data."
             )
         else:
             amplitude = us.UnitfulLength(
                 value=0.0, units=self.unit_system.default_length_units
             )
-            self.logger.warning(
+            logger.warning(
                 "The default tidal amplitude in the GUI will be 0.0, since no tide-gauge water levels are available. You can change this in the site.toml with the 'gui.tide_harmonic_amplitude' attribute."
             )
 
         ref = "MSL"
         if ref not in datum_names:
-            self.logger.warning(
+            logger.warning(
                 f"The Mean Sea Level (MSL) datum is not available in the site.toml. The synthetic tide will be created relative to the main reference: {self.water_level_references.reference}."
             )
             ref = self.water_level_references.reference
@@ -1668,6 +1708,7 @@ class DatabaseBuilder:
 
         return plotting
 
+    @debug_timer
     def create_infometrics(self):
         """
         Copy the infometrics and infographics templates to the appropriate location and modifies the metrics_config.toml files.
@@ -1728,6 +1769,7 @@ class DatabaseBuilder:
             with open(file, "wb") as f:
                 tomli_w.dump(attrs, f)
 
+    @debug_timer
     def _create_optional_infometrics(self, templates_path: Path, path_im: Path):
         # If infographics are going to be created in FA, get template metric configurations
         if not self.config.infographics:
@@ -1736,14 +1778,10 @@ class DatabaseBuilder:
         # Check what type of infographics should be used
         if self.config.unit_system == UnitSystems.imperial:
             metrics_folder_name = "US_NSI"
-            self.logger.info(
-                "Default NSI infometrics and infographics will be created."
-            )
+            logger.info("Default NSI infometrics and infographics will be created.")
         elif self.config.unit_system == UnitSystems.metric:
             metrics_folder_name = "OSM"
-            self.logger.info(
-                "Default OSM infometrics and infographics will be created."
-            )
+            logger.info("Default OSM infometrics and infographics will be created.")
         else:
             raise ValueError(
                 f"Unit system {self.config.unit_system} is not recognized. Please choose 'imperial' or 'metric'."
@@ -1790,6 +1828,7 @@ class DatabaseBuilder:
         path_1 = self.root.joinpath("static", "templates", "infographics", "images")
         shutil.copytree(path_0, path_1)
 
+    @debug_timer
     def add_static_files(self):
         """
         Copy static files from the 'templates' folder to the 'static' folder.
@@ -1804,10 +1843,11 @@ class DatabaseBuilder:
             path_1 = self.static_path / folder
             shutil.copytree(path_0, path_1)
 
+    @debug_timer
     def add_probabilistic_set(self):
         # Copy prob set if given
         if self.config.probabilistic_set:
-            self.logger.info(
+            logger.info(
                 f"Probabilistic event set imported from {self.config.probabilistic_set}"
             )
             prob_event_name = Path(self.config.probabilistic_set).name
@@ -1815,7 +1855,7 @@ class DatabaseBuilder:
             shutil.copytree(self.config.probabilistic_set, path_db)
             self._probabilistic_set_name = prob_event_name
         else:
-            self.logger.warning(
+            logger.warning(
                 "Probabilistic event set not provided. Risk scenarios cannot be run in FloodAdapt."
             )
             self._probabilistic_set_name = None
@@ -1829,7 +1869,7 @@ class DatabaseBuilder:
         the input and static folders. It also creates subfolders within the input and
         static folders based on a predefined list of names.
         """
-        self.logger.info("Preparing the database folder structure.")
+        logger.info("Preparing the database folder structure.")
         inputs = [
             "events",
             "projections",
@@ -1856,6 +1896,23 @@ class DatabaseBuilder:
         else:
             raise ValueError(f"Path {path} is not absolute.")
 
+    def _get_fiat_building_geoms(self) -> gpd.GeoDataFrame:
+        """
+        Get the building geometries from the FIAT model.
+
+        Returns
+        -------
+        gpd.GeoDataFrame
+            A GeoDataFrame containing the building geometries.
+        """
+        building_indices = self._get_fiat_building_index()
+        buildings = pd.concat(
+            [self.fiat_model.exposure.exposure_geoms[i] for i in building_indices],
+            ignore_index=True,
+        )
+        return buildings
+
+    @debug_timer
     def _join_building_footprints(
         self, building_footprints: gpd.GeoDataFrame, field_name: str
     ) -> Path:
@@ -1878,12 +1935,10 @@ class DatabaseBuilder:
         7. Updates the site attributes with the relative path to the saved building footprints.
         8. Logs the location where the building footprints are saved.
         """
-        buildings = self.fiat_model.exposure.exposure_geoms[
-            self._get_fiat_building_index()
-        ]
+        buildings = self._get_fiat_building_geoms()
         exposure_csv = self.fiat_model.exposure.exposure_db
         if "BF_FID" in exposure_csv.columns:
-            self.logger.warning(
+            logger.warning(
                 "Column 'BF_FID' already exists in the exposure columns and will be replaced."
             )
             del exposure_csv["BF_FID"]
@@ -1919,12 +1974,13 @@ class DatabaseBuilder:
 
         # Save site attributes
         buildings_path = geo_path.relative_to(self.static_path)
-        self.logger.info(
+        logger.info(
             f"Building footprints saved at {(self.static_path / buildings_path).resolve().as_posix()}"
         )
 
         return buildings_path
 
+    @debug_timer
     def _clip_hazard_extend(self, clip_footprints=True):
         """
         Clip the exposure data to the bounding box of the hazard data.
@@ -1943,9 +1999,8 @@ class DatabaseBuilder:
         -------
         None
         """
-        gdf = self.fiat_model.exposure.get_full_gdf(
-            self.fiat_model.exposure.exposure_db
-        )
+        gdf = self._get_fiat_gdf_full()
+
         crs = gdf.crs
         sfincs_extend = self.sfincs_overland_model.region
         sfincs_extend = sfincs_extend.to_crs(crs)
@@ -1955,55 +2010,21 @@ class DatabaseBuilder:
         self.fiat_model.geoms["region"] = clipped_region
 
         # Clip the exposure geometries
-        # Filter buildings and roads
-        road_inds = gdf[_FIAT_COLUMNS.primary_object_type].str.contains("road")
-        # Ensure road_inds is a boolean Series
-        if not road_inds.dtype == bool:
-            road_inds = road_inds.astype(bool)
-        # Clip buildings
-        gdf_buildings = gdf[~road_inds]
-        gdf_buildings = self._clip_gdf(
-            gdf_buildings, clipped_region, predicate="within"
-        ).reset_index(drop=True)
-
-        if road_inds.any():
-            # Clip roads
-            gdf_roads = gdf[road_inds]
-            gdf_roads = self._clip_gdf(
-                gdf_roads, clipped_region, predicate="within"
-            ).reset_index(drop=True)
-
-            idx_buildings = self.fiat_model.exposure.geom_names.index(
-                self.config.fiat_buildings_name
-            )
-            idx_roads = self.fiat_model.exposure.geom_names.index(
-                self.config.fiat_roads_name
-            )
-            self.fiat_model.exposure.exposure_geoms[idx_buildings] = gdf_buildings[
-                [_FIAT_COLUMNS.object_id, "geometry"]
-            ]
-            self.fiat_model.exposure.exposure_geoms[idx_roads] = gdf_roads[
-                [_FIAT_COLUMNS.object_id, "geometry"]
-            ]
-            gdf = pd.concat([gdf_buildings, gdf_roads])
-        else:
-            gdf = gdf_buildings
-            self.fiat_model.exposure.exposure_geoms[0] = gdf[
-                [_FIAT_COLUMNS.object_id, "geometry"]
-            ]
+        gdf = self._clip_gdf(gdf, sfincs_extend, predicate="within")
 
         # Save exposure dataframe
         del gdf["geometry"]
         self.fiat_model.exposure.exposure_db = gdf.reset_index(drop=True)
 
+        # Make
+        self._delete_extra_geometries()
+
         # Clip the building footprints
         fieldname = "BF_FID"
         if clip_footprints and not self.fiat_model.building_footprint.empty:
             # Get buildings after filtering and their footprint id
             self.fiat_model.building_footprint = self.fiat_model.building_footprint[
-                self.fiat_model.building_footprint[fieldname].isin(
-                    gdf_buildings[fieldname]
-                )
+                self.fiat_model.building_footprint[fieldname].isin(gdf[fieldname])
             ].reset_index(drop=True)
 
     @staticmethod
@@ -2022,6 +2043,7 @@ class DatabaseBuilder:
         return gdf_new
 
     @staticmethod
+    @debug_timer
     def spatial_join(
         objects: gpd.GeoDataFrame,
         layer: Union[str, gpd.GeoDataFrame],
@@ -2070,14 +2092,25 @@ class DatabaseBuilder:
             layer = layer.rename(columns={field_name: rename})
         return objects_joined, layer
 
-    def _get_fiat_building_index(self) -> int:
-        return self.fiat_model.exposure.geom_names.index(
-            self.config.fiat_buildings_name
+    def _get_fiat_building_index(self) -> list[int]:
+        names = self.config.fiat_buildings_name
+        if isinstance(names, str):
+            names = [names]
+        indices = [
+            self.fiat_model.exposure.geom_names.index(name)
+            for name in names
+            if name in self.fiat_model.exposure.geom_names
+        ]
+        if indices:
+            return indices
+        raise ValueError(
+            f"None of the specified building geometry names {names} found in FIAT model exposure geom_names."
         )
 
     def _get_fiat_road_index(self) -> int:
         return self.fiat_model.exposure.geom_names.index(self.config.fiat_roads_name)
 
+    @debug_timer
     def _get_closest_station(self):
         # Get available stations from source
         obs_data = obs.source(self.config.tide_gauge.source)
@@ -2099,7 +2132,7 @@ class DatabaseBuilder:
         )
 
         distance = us.UnitfulLength(value=distance, units=us.UnitTypesLength.meters)
-        self.logger.info(
+        logger.info(
             f"The closest tide gauge from {self.config.tide_gauge.source} is located {distance.transform(self.unit_system.default_length_units)} from the SFINCS domain"
         )
         # Check if user provided max distance
@@ -2110,7 +2143,7 @@ class DatabaseBuilder:
                 value=distance.convert(units_new), units=units_new
             )
             if distance_new.value > self.config.tide_gauge.max_distance.value:
-                self.logger.warning(
+                logger.warning(
                     f"This distance is larger than the 'max_distance' value of {self.config.tide_gauge.max_distance.value} {units_new} provided in the config file. The station cannot be used."
                 )
                 return None
@@ -2120,6 +2153,7 @@ class DatabaseBuilder:
 
         return station_id
 
+    @debug_timer
     def _get_station_metadata(self, station_id: str, ref: str = "MLLW"):
         """
         Find the closest tide gauge station to the SFINCS domain and retrieves its metadata.
@@ -2166,11 +2200,11 @@ class DatabaseBuilder:
             "lat": station_metadata["lat"],
         }
 
-        self.logger.info(
+        logger.info(
             f"The tide gauge station '{station_metadata['name']}' from {self.config.tide_gauge.source} will be used to download nearshore historical water level time-series."
         )
 
-        self.logger.info(
+        logger.info(
             f"The station metadata will be used to fill in the water_level attribute in the site.toml. The reference level will be {ref}."
         )
 
@@ -2191,14 +2225,69 @@ class DatabaseBuilder:
             bin_colors = tomli.load(f)
         return bin_colors
 
+    def _delete_extra_geometries(self) -> None:
+        """
+        Remove extra geometries from the exposure_geoms list that do not have a corresponding object_id in the exposure_db DataFrame.
 
-if __name__ == "__main__":
+        Returns
+        -------
+            None
+        """
+        # Make sure only csv objects have geometries
+        for i, geoms in enumerate(self.fiat_model.exposure.exposure_geoms):
+            keep = geoms[_FIAT_COLUMNS.object_id].isin(
+                self.fiat_model.exposure.exposure_db[_FIAT_COLUMNS.object_id]
+            )
+            geoms = geoms[keep].reset_index(drop=True)
+            self.fiat_model.exposure.exposure_geoms[i] = geoms
+
+    def _get_fiat_gdf_full(self) -> gpd.GeoDataFrame:
+        """
+        Get the full GeoDataFrame of the Fiat model.
+
+        Returns
+        -------
+            gpd.GeoDataFrame: The full GeoDataFrame of the Fiat model.
+        """
+        gdf = self.fiat_model.exposure.get_full_gdf(
+            self.fiat_model.exposure.exposure_db
+        )
+        # Keep only unique "object_id" rows, keeping the first occurrence
+        gdf = gdf.drop_duplicates(
+            subset=_FIAT_COLUMNS.object_id, keep="first"
+        ).reset_index(drop=True)
+
+        return gdf
+
+
+def main():
     while True:
         config_path = Path(
             input(
                 "Please provide the path to the database creation configuration toml: \n"
             )
         )
+        print(
+            "Please select the log verbosity level for the database creation process.\n"
+            "From most verbose to least verbose: `DEBUG`, `INFO`, `WARNING`.'n"
+        )
+        log_level = input("Enter log level: ")
+        match log_level:
+            case "DEBUG":
+                level = logging.DEBUG
+            case "INFO":
+                level = logging.INFO
+            case "WARNING":
+                level = logging.WARNING
+            case _:
+                print(
+                    f"Log level `{log_level}` not recognized. Defaulting to INFO. Please choose from: `DEBUG`, `INFO`, `WARNING`."
+                )
+                log_level = "INFO"
+                level = logging.INFO
+
+        FloodAdaptLogging(level=level)
+
         try:
             config = ConfigModel.read(config_path)
             dbs = DatabaseBuilder(config)
@@ -2208,3 +2297,7 @@ if __name__ == "__main__":
         quit = input("Do you want to quit? (y/n)")
         if quit == "y":
             exit()
+
+
+if __name__ == "__main__":
+    main()