flood-adapt 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

flood_adapt/database_builder/database_builder.py

@@ -34,12 +34,16 @@ from flood_adapt.config.fiat import (
     SVIModel,
 )
 from flood_adapt.config.gui import (
+    AggregationDmgLayer,
+    BenefitsLayer,
+    FloodMapLayer,
+    FootprintsDmgLayer,
     GuiModel,
     GuiUnitModel,
-    MapboxLayersModel,
+    OutputLayers,
     PlottingModel,
     SyntheticTideModel,
-    VisualizationLayersModel,
+    VisualizationLayers,
 )
 from flood_adapt.config.sfincs import (
     Cstype,
@@ -379,6 +383,7 @@ class DatabaseBuilder:
 
     _has_roads: bool = False
     _aggregation_areas: Optional[list] = None
+    _probabilistic_set_name: Optional[str] = None
 
     def __init__(self, config: ConfigModel, overwrite: bool = True):
         self.config = config
@@ -579,19 +584,26 @@ class DatabaseBuilder:
     ### FIAT ###
     def create_fiat_model(self) -> FiatModel:
         fiat = FiatModel(
-            risk=self.create_risk_model(),
             config=self.create_fiat_config(),
             benefits=self.create_benefit_config(),
+            risk=self.create_risk_model(),
         )
         return fiat
 
-    def create_risk_model(self) -> RiskModel:
+    def create_risk_model(self) -> Optional[RiskModel]:
         # Check if return periods are provided
         if not self.config.return_periods:
-            risk = RiskModel()
-            self.logger.warning(
-                f"Return periods for risk calculations not provided. Default values of {risk.return_periods} will be used."
-            )
+            if self._probabilistic_set_name:
+                risk = RiskModel()
+                self.logger.warning(
+                    f"No return periods provided, but a probabilistic set is available. Using default return periods {risk.return_periods}."
+                )
+                return risk
+            else:
+                self.logger.warning(
+                    "No return periods provided and no probabilistic set available. Risk calculations will not be performed."
+                )
+                return None
         else:
             risk = RiskModel(return_periods=self.config.return_periods)
         return risk
@@ -637,6 +649,8 @@ class DatabaseBuilder:
         # Update elevations
         self.update_fiat_elevation()
 
+        self._svi = self.create_svi()
+
         config = FiatConfigModel(
             exposure_crs=self.fiat_model.exposure.crs,
             floodmap_type=self.read_floodmap_type(),
@@ -649,7 +663,7 @@ class DatabaseBuilder:
             save_simulation=False,  # TODO
             infographics=self.config.infographics,
             aggregation=self._aggregation_areas,
-            svi=self.create_svi(),
+            svi=self._svi,
         )
 
         # Update output geoms names
@@ -1481,23 +1495,28 @@ class DatabaseBuilder:
 
     ### SITE ###
     def create_site_config(self) -> Site:
-        # call this before fiat to ensure the dem is where its expected
-        sfincs = self.create_sfincs_config()
-
-        # call this after sfincs to get waterlevel references
-        gui = self.create_gui_config()
+        """Create the site configuration for the FloodAdapt model.
+
+        The order of these functions is important!
+        1. Create the SFINCS model.
+            needs: water level references
+            provides: updated water level references with optional tide gauge
+        2. Create the FIAT model.
+            needs: water level references and optional probabilistic event set
+            provides: svi and exposure geometries
+        3. Create the GUI model. (requires water level references and FIAT model to be updated)
+            needs: water level references and FIAT model to be updated
+            provides: gui model with output layers, visualization layers and plotting.
 
-        # set the probabilistic event set if provided
+        """
+        sfincs = self.create_sfincs_config()
         self.add_probabilistic_set()
-
-        # Create the FIAT configuration
         fiat = self.create_fiat_model()
-        lon, lat = self.read_location()  # Get centroid of site
+        gui = self.create_gui_config()
 
-        # Set standard objects
+        # Order doesnt matter from here
+        lon, lat = self.read_location()
         std_objs = self.set_standard_objects()
-
-        # Description of site
         description = (
             self.config.description if self.config.description else self.config.name
         )
@@ -1530,7 +1549,7 @@ class DatabaseBuilder:
         gui = GuiModel(
             units=self.unit_system,
             plotting=self.create_hazard_plotting_config(),
-            mapbox_layers=self.create_mapbox_layers_config(),
+            output_layers=self.create_output_layers_config(),
             visualization_layers=self.create_visualization_layers(),
         )
 
@@ -1546,57 +1565,73 @@ class DatabaseBuilder:
                 f"Unit system {self.config.unit_system} not recognized. Please choose 'imperial' or 'metric'."
             )
 
-    def create_visualization_layers(self) -> VisualizationLayersModel:
-        visualization_layers = VisualizationLayersModel(
-            default_bin_number=4,
-            default_colors=["#FFFFFF", "#FEE9CE", "#E03720", "#860000"],
-            layer_names=[],
-            layer_long_names=[],
-            layer_paths=[],
-            field_names=[],
-            bins=[],
-            colors=[],
-        )
-
+    def create_visualization_layers(self) -> VisualizationLayers:
+        visualization_layers = VisualizationLayers()
+        if self._svi is not None:
+            visualization_layers.add_layer(
+                name="svi",
+                long_name="Social Vulnerability Index (SVI)",
+                path=str(self.static_path / self._svi.geom),
+                database_path=self.root,
+                field_name="SVI",
+                bins=[0.05, 0.2, 0.4, 0.6, 0.8],
+            )
         return visualization_layers
 
-    def create_mapbox_layers_config(self) -> MapboxLayersModel:
+    def create_output_layers_config(self) -> OutputLayers:
         # Read default colors from template
         fd_max = self.config.gui.max_flood_depth
         ad_max = self.config.gui.max_aggr_dmg
         ftd_max = self.config.gui.max_footprint_dmg
         b_max = self.config.gui.max_benefits
 
-        svi_bins = None
-        if self.config.svi is not None:
-            svi_bins = [0.05, 0.2, 0.4, 0.6, 0.8]
-
-        mapbox_layers = MapboxLayersModel(
-            flood_map_depth_min=0.0,  # mask areas with flood depth lower than this (zero = all depths shown) # TODO How to define this?
-            flood_map_zbmax=-9999,  # mask areas with elevation lower than this (very negative = show all calculated flood depths) # TODO How to define this?,
-            flood_map_bins=[0.2 * fd_max, 0.6 * fd_max, fd_max],
-            damage_decimals=0,
-            footprints_dmg_type="absolute",
-            aggregation_dmg_bins=[
-                0.00001,
-                0.1 * ad_max,
-                0.25 * ad_max,
-                0.5 * ad_max,
-                ad_max,
-            ],
-            footprints_dmg_bins=[
-                0.00001,
-                0.06 * ftd_max,
-                0.2 * ftd_max,
-                0.4 * ftd_max,
-                ftd_max,
-            ],
-            benefits_bins=[0, 0.01, 0.02 * b_max, 0.2 * b_max, b_max],
-            svi_bins=svi_bins,
-            **self._get_bin_colors(),
-        )
+        benefits_layer = None
+        if self.config.probabilistic_set is not None:
+            benefits_layer = BenefitsLayer(
+                bins=[0, 0.01, 0.02 * b_max, 0.2 * b_max, b_max],
+                colors=[
+                    "#FF7D7D",
+                    "#FFFFFF",
+                    "#DCEDC8",
+                    "#AED581",
+                    "#7CB342",
+                    "#33691E",
+                ],
+                threshold=0.0,
+            )
 
-        return mapbox_layers
+        output_layers = OutputLayers(
+            floodmap=FloodMapLayer(
+                bins=[0.2 * fd_max, 0.6 * fd_max, fd_max],
+                colors=["#D7ECFB", "#8ABDDD", "#1C73A4", "#081D58"],
+                zbmax=-9999,
+                depth_min=0.0,
+            ),
+            aggregation_dmg=AggregationDmgLayer(
+                bins=[0.00001, 0.1 * ad_max, 0.25 * ad_max, 0.5 * ad_max, ad_max],
+                colors=[
+                    "#FFFFFF",
+                    "#FEE9CE",
+                    "#FDBB84",
+                    "#FC844E",
+                    "#E03720",
+                    "#860000",
+                ],
+            ),
+            footprints_dmg=FootprintsDmgLayer(
+                bins=[0.00001, 0.06 * ftd_max, 0.2 * ftd_max, 0.4 * ftd_max, ftd_max],
+                colors=[
+                    "#FFFFFF",
+                    "#FEE9CE",
+                    "#FDBB84",
+                    "#FC844E",
+                    "#E03720",
+                    "#860000",
+                ],
+            ),
+            benefits=benefits_layer,
+        )
+        return output_layers
 
     def create_hazard_plotting_config(self) -> PlottingModel:
         datum_names = [datum.name for datum in self.water_level_references.datums]
@@ -2151,7 +2186,7 @@ class DatabaseBuilder:
         """
         templates_path = Path(__file__).parent.resolve().joinpath("templates")
         with open(
-            templates_path.joinpath("mapbox_layers", "bin_colors.toml"), "rb"
+            templates_path.joinpath("output_layers", "bin_colors.toml"), "rb"
         ) as f:
             bin_colors = tomli.load(f)
         return bin_colors

flood_adapt/dbs_classes/database.py

@@ -381,14 +381,6 @@ class Database(IDatabase):
             runner = BenefitRunner(self, benefit=benefit)
             runner.run_cost_benefit()
 
-    def update(self) -> None:
-        self.projections_list = self._projections.list_objects()
-        self.events_list = self._events.list_objects()
-        self.measures_list = self._measures.list_objects()
-        self.strategies_list = self._strategies.list_objects()
-        self.scenarios_list = self._scenarios.list_objects()
-        self.benefits_list = self._benefits.list_objects()
-
     def get_outputs(self) -> dict[str, Any]:
         """Return a dictionary with info on the outputs that currently exist in the database.
 
@@ -397,7 +389,7 @@ class Database(IDatabase):
         dict[str, Any]
             Includes 'name', 'path', 'last_modification_date' and "finished" info
         """
-        all_scenarios = pd.DataFrame(self._scenarios.list_objects())
+        all_scenarios = pd.DataFrame(self._scenarios.summarize_objects())
         if len(all_scenarios) > 0:
             df = all_scenarios[all_scenarios["finished"]]
         else:
@@ -585,17 +577,17 @@ class Database(IDatabase):
         """
         match object_type:
             case "projections":
-                return self.projections.list_objects()
+                return self.projections.summarize_objects()
             case "events":
-                return self.events.list_objects()
+                return self.events.summarize_objects()
             case "measures":
-                return self.measures.list_objects()
+                return self.measures.summarize_objects()
             case "strategies":
-                return self.strategies.list_objects()
+                return self.strategies.summarize_objects()
             case "scenarios":
-                return self.scenarios.list_objects()
+                return self.scenarios.summarize_objects()
             case "benefits":
-                return self.benefits.list_objects()
+                return self.benefits.summarize_objects()
             case _:
                 raise ValueError(
                     f"Object type '{object_type}' is not valid. Must be one of 'projections', 'events', 'measures', 'strategies' or 'scenarios'."
@@ -611,16 +603,20 @@ class Database(IDatabase):
         scenario_name : str
             name of the scenario to check if needs to be rerun for hazard
         """
-        scenario = self._scenarios.get(scenario_name)
+        scenario = self.scenarios.get(scenario_name)
         runner = ScenarioRunner(self, scenario=scenario)
 
         # Dont do anything if the hazard model has already been run in itself
         if runner.impacts.hazard.has_run:
             return
 
+        scenarios = [
+            self.scenarios.get(scn)
+            for scn in self.scenarios.summarize_objects()["name"]
+        ]
         scns_simulated = [
             sim
-            for sim in self.scenarios.list_objects()["objects"]
+            for sim in scenarios
             if self.scenarios.output_path.joinpath(sim.name, "Flooding").is_dir()
         ]
 
@@ -630,8 +626,9 @@ class Database(IDatabase):
                 path_new = self.scenarios.output_path.joinpath(
                     scenario.name, "Flooding"
                 )
-                runner._load_objects(scn)
-                if runner.impacts.hazard.has_run:  # only copy results if the hazard model has actually finished and skip simulation folders
+                _runner = ScenarioRunner(self, scenario=scn)
+
+                if _runner.impacts.hazard.has_run:  # only copy results if the hazard model has actually finished and skip simulation folders
                     shutil.copytree(
                         existing,
                         path_new,
@@ -642,40 +639,6 @@ class Database(IDatabase):
                         f"Hazard simulation is used from the '{scn.name}' scenario"
                     )
 
-    def run_scenario(self, scenario_name: Union[str, list[str]]) -> None:
-        """Run a scenario hazard and impacts.
-
-        Parameters
-        ----------
-        scenario_name : Union[str, list[str]]
-            name(s) of the scenarios to run.
-
-        Raises
-        ------
-        RuntimeError
-            If an error occurs while running one of the scenarios
-        """
-        if not isinstance(scenario_name, list):
-            scenario_name = [scenario_name]
-
-        errors = []
-
-        for scn in scenario_name:
-            try:
-                self.has_run_hazard(scn)
-                scenario = self.scenarios.get(scn)
-                runner = ScenarioRunner(self, scenario=scenario)
-                runner.run(scenario)
-            except RuntimeError as e:
-                errors.append(scn)
-                self.logger.error(f"Error running scenario {scn}: {e}")
-        if errors:
-            raise RuntimeError(
-                "FloodAdapt failed to run for the following scenarios: "
-                + ", ".join(errors)
-                + ". Check the logs for more information."
-            )
-
     def cleanup(self) -> None:
         """
         Remove corrupted scenario output.

flood_adapt/dbs_classes/dbs_event.py

@@ -67,7 +67,10 @@ class DbsEvent(DbsTemplate[Event]):
             list of scenarios that use the event
         """
         # Get all the scenarios
-        scenarios = self._database.scenarios.list_objects()["objects"]
+        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 = [

flood_adapt/dbs_classes/dbs_measure.py

@@ -37,20 +37,17 @@ class DbsMeasure(DbsTemplate[Measure]):
         # Load and return the object
         return MeasureFactory.get_measure_object(full_path)
 
-    def list_objects(self) -> dict[str, list[Any]]:
+    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' info
+            Includes 'name', 'description', 'path' and 'last_modification_date' and 'geometry' info
         """
-        measures = self._get_object_list()
+        measures = self._get_object_summary()
         objects = [self.get(name) for name in measures["name"]]
 
-        measures["description"] = [obj.description for obj in objects]
-        measures["objects"] = objects
-
         geometries = []
         for obj in objects:
             # If polygon is used read the polygon file
@@ -99,7 +96,10 @@ class DbsMeasure(DbsTemplate[Measure]):
             list of strategies that use the measure
         """
         # Get all the strategies
-        strategies = self._database.strategies.list_objects()["objects"]
+        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 = [

flood_adapt/dbs_classes/dbs_projection.py

@@ -42,7 +42,10 @@ class DbsProjection(DbsTemplate[Projection]):
             list of scenarios that use the projection
         """
         # Get all the scenarios
-        scenarios = self._database.scenarios.list_objects()["objects"]
+        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 = [

flood_adapt/dbs_classes/dbs_scenario.py

@@ -12,7 +12,7 @@ class DbsScenario(DbsTemplate[Scenario]):
     display_name = "Scenario"
     _object_class = Scenario
 
-    def list_objects(self) -> dict[str, list[Any]]:
+    def summarize_objects(self) -> dict[str, list[Any]]:
         """Return a dictionary with info on the events that currently exist in the database.
 
         Returns
@@ -20,12 +20,18 @@ class DbsScenario(DbsTemplate[Scenario]):
         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]
+        scenarios = super().summarize_objects()
+        scenarios["Projection"] = [
+            self._read_variable_in_toml("projection", path)
+            for path in scenarios["path"]
+        ]
+        scenarios["Event"] = [
+            self._read_variable_in_toml("event", path) for path in scenarios["path"]
+        ]
+        scenarios["Strategy"] = [
+            self._read_variable_in_toml("strategy", path) for path in scenarios["path"]
+        ]
+        scenarios["finished"] = [self.has_run_check(scn) for scn in scenarios["name"]]
 
         return scenarios
 
@@ -87,7 +93,10 @@ class DbsScenario(DbsTemplate[Scenario]):
             list[str]
                 list of benefits that use the scenario
         """
-        benefits = self._database.benefits.list_objects()["objects"]
+        benefits = [
+            self._database.benefits.get(benefit)
+            for benefit in self._database.benefits.summarize_objects()["name"]
+        ]
         used_in_benefit = []
         for benefit in benefits:
             runner = BenefitRunner(database=self._database, benefit=benefit)

flood_adapt/dbs_classes/dbs_static.py

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

flood_adapt/dbs_classes/dbs_strategy.py

@@ -40,7 +40,7 @@ class DbsStrategy(DbsTemplate[Strategy]):
         ValueError
             Raise error if name is already in use.
         """
-        object_exists = object_model.name in self.list_objects()["name"]
+        object_exists = object_model.name in self.summarize_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.
@@ -137,11 +137,13 @@ class DbsStrategy(DbsTemplate[Strategy]):
         list[str]
             list of scenarios that use the strategy
         """
-        # Check if strategy is used in a scenario
+        scenarios = [
+            self._database.scenarios.get(scn)
+            for scn in self._database.scenarios.summarize_objects()["name"]
+        ]
+
         used_in_scenario = [
-            scenario.name
-            for scenario in self._database.scenarios.list_objects()["objects"]
-            if name == scenario.strategy
+            scenario.name for scenario in scenarios if name == scenario.strategy
         ]
 
         return used_in_scenario

flood_adapt/dbs_classes/dbs_template.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, TypeVar
 
+import tomli
 import tomli_w
 
 from flood_adapt.dbs_classes.interface.database import IDatabase
@@ -47,25 +48,16 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
         # Load and return the object
         return self._object_class.load_file(full_path)
 
-    def list_objects(self) -> dict[str, list[Any]]:
+    def summarize_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'
+            A dictionary that contains the keys: `name`, `description`, `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.
         """
-        # Check if all objects exist
-        object_list = self._get_object_list()
-
-        # Load all objects
-        objects = [self.get(name) for name in object_list["name"]]
-
-        # From the loaded objects, get the description and add them to the object_list
-        object_list["description"] = [obj.description for obj in objects]
-        object_list["objects"] = objects
-        return object_list
+        return self._get_object_summary()
 
     def copy(self, old_name: str, new_name: str, new_description: str):
         """Copy (duplicate) an existing object, and give it a new name.
@@ -155,7 +147,7 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
             Raise error if name is already in use.
         """
         # Check if the object exists
-        if object_model.name not in self.list_objects()["name"]:
+        if object_model.name not in self.summarize_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."
             )
@@ -241,13 +233,13 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
         # level object. By default, return an empty list
         return []
 
-    def _get_object_list(self) -> dict[str, list[Any]]:
+    def _get_object_summary(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`
+            A dictionary that contains the keys: `name`, `description`, `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.
@@ -258,19 +250,30 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
             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]
+
+        names = [self._read_variable_in_toml("name", path) for path in paths]
+        descriptions = [
+            self._read_variable_in_toml("description", path) for path in paths
+        ]
+
         last_modification_date = [
             datetime.fromtimestamp(file.stat().st_mtime) for file in paths
         ]
 
         objects = {
             "name": names,
+            "description": descriptions,
             "path": paths,
             "last_modification_date": last_modification_date,
         }
-
         return objects
 
+    @staticmethod
+    def _read_variable_in_toml(variable_name: str, toml_path: Path) -> str:
+        with open(toml_path, "rb") as f:
+            data = tomli.load(f)
+        return data.get(variable_name, "")
+
     def _validate_to_save(self, object_model: T_OBJECTMODEL, overwrite: bool) -> None:
         """Validate if the object can be saved.
 
@@ -285,11 +288,7 @@ class DbsTemplate(AbstractDatabaseElement[T_OBJECTMODEL]):
             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"]
+        object_exists = object_model.name in self.summarize_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.

flood_adapt/dbs_classes/interface/database.py

@@ -86,10 +86,6 @@ class IDatabase(ABC):
     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
@@ -138,10 +134,6 @@ class IDatabase(ABC):
     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

@@ -33,7 +33,7 @@ class AbstractDatabaseElement(ABC, Generic[T_OBJECT_MODEL]):
         pass
 
     @abstractmethod
-    def list_objects(self) -> dict[str, list[Any]]:
+    def summarize_objects(self) -> dict[str, list[Any]]:
         """Return a dictionary with info on the objects that currently exist in the database.
 
         Returns