fameio 3.1.1__py3-none-any.whl → 3.3.0__py3-none-any.whl

fameio/output/conversion.py

@@ -1,55 +1,62 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import math
-from typing import Optional
 
 import pandas as pd
 
 from fameio.cli.options import TimeOptions
-from fameio.logs import log_error_and_raise, log
-from fameio.time import ConversionError, FameTime
+from fameio.logs import log_error, log
+from fameio.output import OutputError
+from fameio.time import FameTime, ConversionError as TimeConversionError
 
 _ERR_UNIMPLEMENTED = "Time conversion mode '{}' not implemented."
+_ERR_TIME_CONVERSION = "Conversion of timestamps failed."
 _ERR_NEGATIVE = "StepsBefore and StepsAfter must be Zero or positive integers"
 
 
-def _apply_time_merging(
-    dataframes: dict[Optional[str], pd.DataFrame], offset: int, period: int, first_positive_focal_point: int
-) -> None:
-    """Applies time merging to `data` based on given `offset`, `period`, and `first_positive_focal_point`"""
-    log().debug("Grouping TimeSteps...")
-    for key in dataframes.keys():
-        df = dataframes[key]
-        index_columns = df.index.names
-        df.reset_index(inplace=True)
-        df["TimeStep"] = df["TimeStep"].apply(lambda t: merge_time(t, first_positive_focal_point, offset, period))
-        dataframes[key] = df.groupby(by=index_columns).sum()
+class ConversionError(OutputError):
+    """An error that occurred during conversion of output data."""
 
 
-def apply_time_merging(data: dict[Optional[str], pd.DataFrame], config: Optional[list[int]]) -> None:
-    """
-    Applies merging of TimeSteps inplace for given `data`
+def apply_time_merging(data: dict[str | None, pd.DataFrame], config: list[int] | None) -> None:
+    """Applies merging of TimeSteps inplace for given `data`.
 
     Args:
         data: one or multiple DataFrames of time series; depending on the given config, contents might be modified
         config: three integer values defining how to merge data within a range of time steps
+
+    Raises:
+        ConversionError: if parameters are not valid, logged with level "ERROR"
     """
     if not config or all(v == 0 for v in config):
         return
     focal_point, steps_before, steps_after = config
     if steps_before < 0 or steps_after < 0:
-        raise ValueError(_ERR_NEGATIVE)
+        raise log_error(ConversionError(_ERR_NEGATIVE))
 
     period = steps_before + steps_after + 1
     first_positive_focal_point = focal_point % period
     _apply_time_merging(data, offset=steps_before, period=period, first_positive_focal_point=first_positive_focal_point)
 
 
-def merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int:
-    """
-    Returns `time_step` rounded to its corresponding focal point
+def _apply_time_merging(
+    dataframes: dict[str | None, pd.DataFrame], offset: int, period: int, first_positive_focal_point: int
+) -> None:
+    """Applies time merging to `data` based on given `offset`, `period`, and `first_positive_focal_point`."""
+    log().debug("Grouping TimeSteps...")
+    for key in dataframes.keys():
+        df = dataframes[key]
+        index_columns = df.index.names
+        df.reset_index(inplace=True)
+        df["TimeStep"] = df["TimeStep"].apply(lambda t: _merge_time(t, first_positive_focal_point, offset, period))
+        dataframes[key] = df.groupby(by=index_columns).sum()
+
+
+def _merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int:
+    """Returns `time_step` rounded to its corresponding focal point.
 
     Args:
         time_step: TimeStep to round
@@ -63,32 +70,40 @@ def merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int
     return math.floor((time_step + offset - focal_time) / period) * period + focal_time
 
 
-def apply_time_option(data: dict[Optional[str], pd.DataFrame], mode: TimeOptions) -> None:
-    """
-    Applies time option based on given `mode` inplace of given `data`
+def apply_time_option(data: dict[str | None, pd.DataFrame], mode: TimeOptions) -> None:
+    """Applies time option based on given `mode` inplace of given `data`.
 
     Args:
         data: one or multiple DataFrames of time series; column `TimeStep` might be modified (depending on mode)
         mode: name of time conversion mode (derived from Enum)
+
+    Raises:
+        ConversionError: if provided mode is not implemented , logged with level "ERROR"
     """
-    if mode == TimeOptions.INT:
-        log().debug("No time conversion...")
-    elif mode == TimeOptions.UTC:
-        _convert_time_index(data, "%Y-%m-%d %H:%M:%S")
-    elif mode == TimeOptions.FAME:
-        _convert_time_index(data, "%Y-%m-%d_%H:%M:%S")
-    else:
-        log_error_and_raise(ConversionError(_ERR_UNIMPLEMENTED.format(mode)))
+    try:
+        if mode == TimeOptions.INT:
+            log().debug("No time conversion...")
+        elif mode == TimeOptions.UTC:
+            _convert_time_index(data, "%Y-%m-%d %H:%M:%S")
+        elif mode == TimeOptions.FAME:
+            _convert_time_index(data, "%Y-%m-%d_%H:%M:%S")
+        else:
+            raise log_error(ConversionError(_ERR_UNIMPLEMENTED.format(mode)))
+    except TimeConversionError as e:
+        raise log_error(ConversionError(_ERR_TIME_CONVERSION.format())) from e
 
 
-def _convert_time_index(data: dict[Optional[str], pd.DataFrame], datetime_format: str) -> None:
-    """
-    Inplace replacement of `TimeStep` column in MultiIndex of each item of `data` from FAME's time steps` to DateTime
-    in given `date_format`
+def _convert_time_index(data: dict[str | None, pd.DataFrame], datetime_format: str) -> None:
+    """Replaces (inplace) `TimeStep` column in MultiIndex of each item of `data` to DateTime.
+
+    Format of the resulting DateTime is determined by given `date_format`.
 
     Args:
         data: one or multiple DataFrames of time series; column `TimeStep` will be modified
-        datetime_format: used for the conversion
+        datetime_format: determines result of the conversion
+
+    Raises:
+        TimeConversionError: if time cannot be converted, logged with level "ERROR"
     """
     log().debug(f"Converting TimeStep to format '{datetime_format}'...")
     for _, df in data.items():

fameio/output/csv_writer.py

@@ -1,19 +1,29 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 from pathlib import Path
-from typing import Union
 
 import pandas as pd
 
-from fameio.logs import log
+from fameio.logs import log, log_error
+from fameio.output import OutputError
 from fameio.output.data_transformer import INDEX
 from fameio.series import TimeSeriesManager
 from fameio.tools import ensure_path_exists
 
 
+class CsvWriterError(OutputError):
+    """An error occurred during writing a CSV file."""
+
+
 class CsvWriter:
-    """Writes dataframes to different csv files"""
+    """Writes dataframes to different csv files."""
+
+    _ERR_DIR_CREATE = "Could not create directory for output files: '{}'"
+    _ERR_FILE_OPEN = "Could not open file for writing: '{}'"
+    _ERR_FILE_WRITE = "Could not write to file '{}' due to: {}"
 
     _INFO_USING_PATH = "Using specified output path: {}"
     _INFO_USING_DERIVED_PATH = "No output path specified - writing to new local folder: {}"
@@ -21,16 +31,21 @@ class CsvWriter:
     CSV_FILE_SUFFIX = ".csv"
 
     def __init__(self, config_output: Path, input_file_path: Path, single_export: bool) -> None:
+        """Constructs a new CsvWriter.
+
+        Raises:
+             CsvWriterError: if output folder could not be created, logged with level "ERROR"
+        """
         self._single_export = single_export
         self._output_folder = self._get_output_folder_name(config_output, input_file_path)
-        self._files = {}
+        self._files: dict[str, Path] = {}
         self._create_output_folder()
 
     @staticmethod
     def _get_output_folder_name(config_output: Path, input_file_path: Path) -> Path:
-        """Returns name of the output folder derived either from the specified `config_output` or `input_file_path`"""
+        """Returns name of the output folder derived either from the specified `config_output` or `input_file_path`."""
         if config_output:
-            output_folder_name = config_output
+            output_folder_name: str | Path = config_output
             log().info(CsvWriter._INFO_USING_PATH.format(config_output))
         else:
             output_folder_name = input_file_path.stem
@@ -38,13 +53,28 @@ class CsvWriter:
         return Path(output_folder_name)
 
     def _create_output_folder(self) -> None:
-        """Creates output folder if not yet present"""
+        """Creates output folder if not yet present.
+
+        Raises:
+            CsvWriterError: if output folder could not be created, logged with level "ERROR"
+        """
         log().debug("Creating output folder if required...")
         if not self._output_folder.is_dir():
-            self._output_folder.mkdir(parents=True)
+            try:
+                self._output_folder.mkdir(parents=True)
+            except OSError as e:
+                raise log_error(CsvWriterError(self._ERR_DIR_CREATE.format(self._output_folder))) from e
+
+    def write_to_files(self, agent_name: str, data: dict[None | str, pd.DataFrame]) -> None:
+        """Writes `data` for given `agent_name` to .csv file(s).
+
+        Args:
+            agent_name: name of agent whose data are to be written to file(s)
+            data: previously extracted data for that agent that are to be written
 
-    def write_to_files(self, agent_name: str, data: dict[Union[None, str], pd.DataFrame]) -> None:
-        """Writes `data` for given `agent_name` to .csv file(s)"""
+        Raises:
+            CsvWriterError: when file could not be written, logged on level "ERROR"
+        """
         for column_name, column_data in data.items():
             column_data.sort_index(inplace=True)
             if self._single_export:
@@ -55,17 +85,57 @@ class CsvWriter:
                 identifier = self._get_identifier(agent_name, column_name)
                 self._write_data_frame(column_data, identifier)
 
-    def write_time_series_to_disk(self, timeseries_manager: TimeSeriesManager) -> None:
-        """Writes time_series of given `timeseries_manager` to disk"""
+    def write_all_time_series_to_disk(self, timeseries_manager: TimeSeriesManager) -> None:
+        """Writes time_series of given `timeseries_manager` to disk.
+
+        Args:
+            timeseries_manager: to provide the time series that are to be written
+
+        Raises:
+            CsvWriterError: if data could not be written to disk, logged on level "ERROR"
+        """
         for _, name, data in timeseries_manager.get_all_series():
             if data is not None:
                 target_path = Path(self._output_folder, name)
                 ensure_path_exists(target_path.parent)
-                # noinspection PyTypeChecker
-                data.to_csv(path_or_buf=target_path, sep=";", header=None, index=None)
+                self.write_single_time_series_to_disk(data, target_path)
 
     @staticmethod
-    def _get_identifier(agent_name: str, column_name: str, agent_id: str = None) -> str:
+    def write_single_time_series_to_disk(data: pd.DataFrame, file: Path) -> None:
+        """Writes given timeseries the provided file path.
+
+        Args:
+            data: to be written
+            file: target path of csv file
+
+        Raises:
+            CsvWriterError: if data could not be written to disk, logged on level "ERROR"
+        """
+        CsvWriter._dataframe_to_csv(data, file, header=False, index=False, mode="w")
+
+    @staticmethod
+    def _dataframe_to_csv(data: pd.DataFrame, file: Path, header: bool, index: bool, mode: str) -> None:
+        """Write given data to specified CSV file with specified parameters using semicolon separators.
+
+        Args:
+            data: to be written
+            file: target path of csv file
+            header: write column headers
+            index: write index column(s)
+            mode: append to or overwrite file
+
+        Raises:
+            CsvWriterError: if data could not be written to disk, logged on level "ERROR"
+        """
+        try:
+            data.to_csv(path_or_buf=file, sep=";", header=header, index=index, mode=mode)
+        except OSError as e:
+            raise log_error(CsvWriterError(CsvWriter._ERR_FILE_OPEN.format(file))) from e
+        except UnicodeError as e:
+            raise log_error(CsvWriterError(CsvWriter._ERR_FILE_WRITE.format(file, str(e)))) from e
+
+    @staticmethod
+    def _get_identifier(agent_name: str, column_name: str | None = None, agent_id: str | None = None) -> str:
         """Returns unique identifier for given `agent_name` and (optional) `agent_id` and `column_name`"""
         identifier = str(agent_name)
         if column_name:
@@ -75,36 +145,46 @@ class CsvWriter:
         return identifier
 
     def _write_data_frame(self, data: pd.DataFrame, identifier: str) -> None:
-        """
-        Appends `data` to existing csv file derived from `identifier` without headers,
-        or writes new file with headers instead
+        """Writes `data` to csv file derived from `identifier`.
+
+        Appends data if csv file exists, else writes new file with headers instead.
+
+        Args:
+            data: to be written to file
+            identifier: to derive the file name from
+
+        Raises:
+            CsvWriterError: when file could not be written, logged on level "ERROR"
         """
         if self._has_file(identifier):
             outfile_name = self._get_outfile_name(identifier)
-            data.to_csv(outfile_name, sep=";", index=True, header=False, mode="a")
+            mode = "a"
+            header = False
         else:
             outfile_name = self._create_outfile_name(identifier)
             self._save_outfile_name(outfile_name, identifier)
-            data.to_csv(outfile_name, sep=";", index=True, header=True)
+            mode = "w"
+            header = True
+        self._dataframe_to_csv(data, outfile_name, header=header, index=True, mode=mode)
 
     def _has_file(self, identifier: str) -> bool:
-        """Returns True if a file for given `identifier` was already written"""
+        """Returns True if a file for given `identifier` was already written."""
         return identifier in self._files
 
     def pop_all_file_paths(self) -> dict[str, Path]:
-        """Clears all stored file paths and returns their previous identifiers and their paths"""
+        """Clears all stored file paths and returns their previous identifiers and their paths."""
         current_files = self._files
         self._files = {}
         return current_files
 
-    def _get_outfile_name(self, identifier: str) -> str:
-        """Returns file name for given `agent_name` and (optional) `agent_id`"""
+    def _get_outfile_name(self, identifier: str) -> Path:
+        """Returns file path for given `agent_name` and (optional) `agent_id`."""
         return self._files[identifier]
 
     def _create_outfile_name(self, identifier: str) -> Path:
-        """Returns fully qualified file name based on given `agent_name` and (optional) `agent_id`"""
+        """Returns fully qualified file path based on given `agent_name` and (optional) `agent_id`."""
         return Path(self._output_folder, f"{identifier}{self.CSV_FILE_SUFFIX}")
 
     def _save_outfile_name(self, outfile_name: Path, identifier: str) -> None:
-        """Stores given name for given `agent_name` and (optional) `agent_id`"""
+        """Stores given name for given `agent_name` and (optional) `agent_id`."""
         self._files[identifier] = outfile_name

fameio/output/data_transformer.py

@@ -4,8 +4,6 @@
 from __future__ import annotations
 
 from abc import ABC
-from builtins import staticmethod
-from typing import Union, Optional
 
 import pandas as pd
 from fameprotobuf.services_pb2 import Output
@@ -18,7 +16,7 @@ INDEX = ("AgentId", "TimeStep")
 
 
 class DataTransformer(ABC):
-    """Extracts and provides series data from parsed and processed output files for requested agents"""
+    """Extracts and provides series data from parsed and processed output files for requested agents."""
 
     MODES = {
         ResolveOptions.IGNORE: lambda: DataTransformerIgnore(),  # pylint: disable=unnecessary-lambda
@@ -30,13 +28,11 @@ class DataTransformer(ABC):
     def build(complex_column_mode: ResolveOptions) -> DataTransformer:
         return DataTransformer.MODES[complex_column_mode]()
 
-    def extract_agent_data(
-        self, series: list[Output.Series], agent_type: AgentType
-    ) -> dict[Optional[str], pd.DataFrame]:
-        """
-        Returns dict of DataFrame(s) containing all data from given `series` of given `agent_type`.
+    def extract_agent_data(self, series: list[Output.Series], agent_type: AgentType) -> dict[str | None, pd.DataFrame]:
+        """Returns dict of DataFrame(s) containing all data from given `series` of given `agent_type`.
+
         When ResolveOption is `SPLIT`, the dict maps each complex column's name to the associated DataFrame.
-        In any case, the dict maps `None` to a DataFrame with the content of all simple column / merged columns.
+        In any case, the dict maps `None` to a DataFrame with the content of all simple columns.
         """
         container = self._extract_agent_data(series, agent_type)
         data_frames = {}
@@ -45,7 +41,7 @@ class DataTransformer(ABC):
             column_name = agent_type.get_column_name_for_id(column_id)
             if column_id == DataTransformer.SIMPLE_COLUMN_INDEX:
                 data_frame.rename(columns=self._get_column_map(agent_type), inplace=True)
-                index = INDEX
+                index: tuple[str, ...] = INDEX
                 data_frame = data_frame.loc[:, agent_type.get_simple_column_mask()]
             else:
                 data_frame.rename(columns={0: column_name}, inplace=True)
@@ -59,8 +55,8 @@ class DataTransformer(ABC):
 
     def _extract_agent_data(
         self, series: list[Output.Series], agent_type: AgentType
-    ) -> dict[int, dict[tuple, list[Union[float, None, str]]]]:
-        """Returns mapping of (agentId, timeStep) to fixed-length list of all output columns for given `class_name`"""
+    ) -> dict[int, dict[tuple, list[float | None | str]]]:
+        """Returns mapping of (agentId, timeStep) to fixed-length list of all output columns for given `class_name`."""
         container = DataTransformer._create_container(agent_type)
         mask_simple = agent_type.get_simple_column_mask()
         while series:
@@ -70,7 +66,7 @@ class DataTransformer(ABC):
 
     @staticmethod
     def _create_container(agent_type: AgentType) -> dict[int, dict]:
-        """Returns map of complex columns IDs to an empty dict, and one more for the remaining simple columns"""
+        """Returns map of complex columns IDs to an empty dict, and one more for the remaining simple columns."""
         field_ids = agent_type.get_complex_column_ids().union([DataTransformer.SIMPLE_COLUMN_INDEX])
         return {field_id: {} for field_id in field_ids}
 
@@ -78,9 +74,9 @@ class DataTransformer(ABC):
         self,
         series: Output.Series,
         mask_simple: list[bool],
-        container: dict[int, dict[tuple, list[Union[float, None, str]]]],
+        container: dict[int, dict[tuple, list[float | None | str]]],
     ) -> None:
-        """Adds data from given `series` to specified `container` dict as list"""
+        """Adds data from given `series` to specified `container` dict as list."""
         empty_list: list = [None] * len(mask_simple)
         for line in series.lines:
             index = (series.agent_id, line.time_step)
@@ -89,32 +85,29 @@ class DataTransformer(ABC):
                 if mask_simple[column.field_id]:
                     simple_values[column.field_id] = column.value
                 else:
-                    self._merge_complex_column(column, simple_values)
                     self._store_complex_values(column, container, index)
             container[DataTransformer.SIMPLE_COLUMN_INDEX][index] = simple_values
 
-    @staticmethod
-    def _merge_complex_column(column: Output.Series.Line.Column, values: list) -> None:
-        """Merges complex column data"""
-
     @staticmethod
     def _store_complex_values(column: Output.Series.Line.Column, container: dict[int, dict], base_index: tuple) -> None:
-        """Stores complex column data"""
+        """Stores complex column data."""
 
     @staticmethod
     def _get_column_map(agent_type: AgentType) -> dict[int, str]:
-        """Returns mapping of simple column IDs to their name for given `agent_type`"""
+        """Returns mapping of simple column IDs to their name for given `agent_type`."""
         return agent_type.get_simple_column_map()
 
 
 class DataTransformerIgnore(DataTransformer):
-    """Ignores complex columns on output"""
+    """Ignores complex columns on output."""
 
 
 class DataTransformerSplit(DataTransformer):
+    """Stores complex data columns split by column type."""
+
     @staticmethod
     def _store_complex_values(column: Output.Series.Line.Column, container: dict[int, dict], base_index: tuple) -> None:
-        """Adds inner data from `column` to given `container` - split by column type"""
+        """Adds inner data from `column` to given `container` - split by column type."""
         for entry in column.entries:
             index = base_index + tuple(entry.index_values)
             container[column.field_id][index] = entry.value

fameio/output/execution_dao.py

@@ -0,0 +1,170 @@
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any, Final
+
+from fameprotobuf.data_storage_pb2 import DataStorage
+from fameprotobuf.execution_data_pb2 import ExecutionData
+from google.protobuf import message
+
+from fameio.logs import log_error
+from fameio.output import OutputError
+
+
+class ExecutionDataError(OutputError):
+    """Indicates an error during reconstruction of execution metadata from its protobuf representation."""
+
+
+VERSION_MAP: Final[dict[str, str]] = {
+    "fame_protobuf": "FameProtobuf",
+    "fame_io": "FameIo",
+    "fame_core": "FameCore",
+    "python": "Python",
+    "jvm": "JavaVirtualMachine",
+    "os": "OperatingSystem",
+}
+PROCESS_MAP: Final[dict[str, str]] = {
+    "core_count": "NumberOfCores",
+    "output_interval": "OutputIntervalInTicks",
+    "output_process": "ProcessControllingOutputs",
+}
+STATISTICS_MAP: Final[dict[str, str]] = {
+    "start": "SimulationBeginInRealTime",
+    "duration_in_ms": "SimulationWallTimeInMillis",
+    "tick_count": "SimulatedTicks",
+}
+
+
+class ExecutionDao:
+    """Data access object for execution metadata saved in protobuf."""
+
+    _ERR_MULTIPLE_VERSIONS = "More than two version metadata sections found: File is corrupt."
+    _ERR_MULTIPLE_CONFIGURATIONS = "More than one configuration metadata section found: File is corrupt."
+    _ERR_MULTIPLE_SIMULATIONS = "More than one simulation metadata section found: File is corrupt."
+    _ERR_NO_VERSION = "No version data found: File is either corrupt or was created with fameio version < 3.0."
+
+    KEY_COMPILATION: Final[str] = "InputCompilation"
+    KEY_RUN: Final[str] = "ModelRun"
+    KEY_VERSIONS: Final[str] = "SoftwareVersions"
+    KEY_PROCESSES: Final[str] = "ProcessConfiguration"
+    KEY_STATISTICS: Final[str] = "Statistics"
+
+    def __init__(self) -> None:
+        self._compile_versions: ExecutionData.VersionData | None = None
+        self._run_versions: ExecutionData.VersionData | None = None
+        self._run_configuration: ExecutionData.ProcessConfiguration | None = None
+        self._run_simulation: ExecutionData.Simulation | None = None
+
+    def store_execution_metadata(self, data_storages: list[DataStorage]) -> None:
+        """Scans given data storages for execution metadata.
+
+        If metadata are present, they are extracted for later inspection
+
+        Args:
+            data_storages: to be scanned for execution metadata
+
+        Raises:
+            ExecutionDataError: if more execution sections are found than expected, logged with level "ERROR"
+        """
+        for entry in [storage.execution for storage in data_storages if storage.HasField("execution")]:
+            if entry.HasField("version_data"):
+                self._add_version_data(entry.version_data)
+            if entry.HasField("configuration"):
+                self._add_configuration(entry.configuration)
+            if entry.HasField("simulation"):
+                self._add_simulation(entry.simulation)
+
+    def _add_version_data(self, data: ExecutionData.VersionData) -> None:
+        """Stores given version metadata.
+
+        Args:
+            data: version data saved during compilation (first call), or during model run (second call)
+
+        Raises:
+            ExecutionDataError: if both version data are already set, logged with level "ERROR"
+        """
+        if not self._compile_versions:
+            self._compile_versions = data
+        elif not self._run_versions:
+            self._run_versions = data
+        else:
+            raise log_error(ExecutionDataError(self._ERR_MULTIPLE_VERSIONS))
+
+    def _add_configuration(self, data: ExecutionData.ProcessConfiguration) -> None:
+        """Stores given process configuration metadata.
+
+        Args:
+            data: process configuration data to be saved
+
+        Raises:
+            ExecutionDataError: if process configuration data are already set, logged with level "ERROR"
+        """
+        if not self._run_configuration:
+            self._run_configuration = data
+        else:
+            raise log_error(ExecutionDataError(self._ERR_MULTIPLE_CONFIGURATIONS))
+
+    def _add_simulation(self, data: ExecutionData.Simulation) -> None:
+        """Stores given simulation metadata.
+
+        Args:
+            data: simulation metadata to be stored
+
+        Raises:
+            ExecutionDataError: if simulation metadata are already set, logged with level "ERROR"
+        """
+        if not self._run_simulation:
+            self._run_simulation = data
+        else:
+            raise log_error(ExecutionDataError(self._ERR_MULTIPLE_SIMULATIONS))
+
+    def get_fameio_version(self) -> str:
+        """Gets version of fameio used to create the input data.
+
+        Returns:
+            fameio version that was used to create the input data
+
+        Raises:
+            ExecutionDataError: if fameio version could not be read, logged with level "ERROR"
+        """
+        if self._compile_versions:
+            return self._compile_versions.fame_io
+        raise log_error(ExecutionDataError(self._ERR_NO_VERSION))
+
+    def get_metadata_dict(self) -> dict[str, Any]:
+        """Creates a dictionary from all provided execution metadata.
+
+        Returns:
+            dictionary with all execution metadata currently stored in this DAO
+        """
+        result = {
+            self.KEY_COMPILATION: {self.KEY_VERSIONS: self._get_dict(self._compile_versions, VERSION_MAP)},
+            self.KEY_RUN: {
+                self.KEY_VERSIONS: self._get_dict(self._run_versions, VERSION_MAP),
+                self.KEY_PROCESSES: self._get_dict(self._run_configuration, PROCESS_MAP),
+                self.KEY_STATISTICS: self._get_dict(self._run_simulation, STATISTICS_MAP),
+            },
+        }
+        return result
+
+    @staticmethod
+    def _get_dict(data: message, replacements: dict[str, str]) -> dict[str, str]:
+        """Searches for `replacements.keys()` in provided `data`.
+
+        If key is available, saves the corresponding data item to dict, associated to a name matching the value in `replacements`.
+
+        Args:
+            data: to extract data from
+            replacements: keys to be replaced by their values in the resulting dict
+
+        Returns:
+            a dictionary matching entries from `data` with their new keys as specified under "replacements"
+        """
+        versions = {}
+        if data is not None:
+            for key, replacement in replacements.items():
+                if data.HasField(key):
+                    versions[replacement] = getattr(data, key)
+        return versions