fameio 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

fameio/output/agent_type.py

@@ -10,7 +10,7 @@ from fameio.output import OutputError
 
 
 class AgentType:
-    """Provides information derived from an underlying protobuf AgentType"""
+    """Provides information derived from an underlying protobuf AgentType."""
 
     def __init__(self, agent_type: Output.AgentType) -> None:
         self._agent_type = agent_type
@@ -53,18 +53,17 @@ class AgentType:
 
 
 class AgentTypeError(OutputError):
-    """Indicates an error with the agent types definitions"""
+    """Indicates an error with the agent types definitions."""
 
 
 class AgentTypeLog:
-    """Stores data about collected agent types"""
+    """Stores data about collected agent types."""
 
     _ERR_AGENT_TYPE_MISSING = "Requested AgentType `{}` not found."
     _ERR_DOUBLE_DEFINITION = "Just one definition allowed per AgentType. Found multiple for {}. File might be corrupt."
 
     def __init__(self, _agent_name_filter_list: list[str]) -> None:
-        """
-        Initialises new AgentTypeLog
+        """Initialises new AgentTypeLog.
 
         Args:
             _agent_name_filter_list: list of agent type names that are requested for output data extraction
@@ -76,8 +75,10 @@ class AgentTypeLog:
         self._agents_with_output: list[str] = []
 
     def update_agents(self, new_types: dict[str, Output.AgentType]) -> None:
-        """
-        If any new `agent_types` are provided, checks if they are requested for extraction, and, if so, saves them
+        """Saves `new_types` if they are requested for extraction.
+
+        If any new agent types are provided, checks if they are requested for extraction, and, if so, saves them.
+        Agent types not requested for extraction are ignored.
 
         Args:
             new_types: to be saved (if requested for extraction)
@@ -94,8 +95,7 @@ class AgentTypeLog:
         self._requested_agent_types.update(filtered_types)
 
     def _filter_agents_by_name(self, new_types: dict[str, Output.AgentType]) -> dict[str, Output.AgentType]:
-        """
-        Removes and entries from `new_types` not on `agent_name_filter_list`
+        """Removes and entries from `new_types` not on `agent_name_filter_list`.
 
         Args:
             new_types: to be filtered
@@ -112,8 +112,7 @@ class AgentTypeLog:
         return new_types
 
     def _ensure_no_duplication(self, filtered_types: dict[str, Output.AgentType]) -> None:
-        """
-        Ensures no duplicate agent type definitions occur
+        """Ensures no duplicate agent type definitions occur.
 
         Args:
             filtered_types: to be checked for duplications with already registered types
@@ -126,12 +125,11 @@ class AgentTypeLog:
                 raise log_error(AgentTypeError(self._ERR_DOUBLE_DEFINITION.format(agent_name)))
 
     def has_any_agent_type(self) -> bool:
-        """Returns True if any agent type was registered so far present"""
+        """Returns True if any agent type was registered so far present."""
         return len(self._requested_agent_types) > 0
 
     def get_agent_type(self, agent_type_name: str) -> AgentType:
-        """
-        Returns the requested type of agent
+        """Returns the requested type of agent.
 
         Args:
             agent_type_name: requested name of agent type
@@ -147,9 +145,9 @@ class AgentTypeLog:
         return AgentType(self._requested_agent_types[agent_type_name])
 
     def is_requested(self, agent_name: str) -> bool:
-        """Returns True if given agent_name is known and requested"""
+        """Returns True if given agent_name is known and requested."""
         return agent_name in self._requested_agent_types
 
     def get_agents_with_output(self) -> list[str]:
-        """Returns all names of agents that had output"""
+        """Returns all names of agents that had output."""
         return self._agents_with_output

fameio/output/conversion.py

@@ -18,12 +18,11 @@ _ERR_NEGATIVE = "StepsBefore and StepsAfter must be Zero or positive integers"
 
 
 class ConversionError(OutputError):
-    """An error that occurred during conversion of output data"""
+    """An error that occurred during conversion of output data."""
 
 
 def apply_time_merging(data: dict[str | None, pd.DataFrame], config: list[int] | None) -> None:
-    """
-    Applies merging of TimeSteps inplace for given `data`
+    """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
@@ -46,7 +45,7 @@ def apply_time_merging(data: dict[str | None, pd.DataFrame], config: list[int] |
 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`"""
+    """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]
@@ -57,8 +56,7 @@ def _apply_time_merging(
 
 
 def _merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int:
-    """
-    Returns `time_step` rounded to its corresponding focal point
+    """Returns `time_step` rounded to its corresponding focal point.
 
     Args:
         time_step: TimeStep to round
@@ -73,8 +71,7 @@ def _merge_time(time_step: int, focal_time: int, offset: int, period: int) -> in
 
 
 def apply_time_option(data: dict[str | None, pd.DataFrame], mode: TimeOptions) -> None:
-    """
-    Applies time option based on given `mode` inplace of given `data`
+    """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)
@@ -97,13 +94,13 @@ def apply_time_option(data: dict[str | None, pd.DataFrame], mode: TimeOptions) -
 
 
 def _convert_time_index(data: dict[str | None, 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`
+    """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"

fameio/output/csv_writer.py

@@ -15,11 +15,11 @@ from fameio.tools import ensure_path_exists
 
 
 class CsvWriterError(OutputError):
-    """An error occurred during writing a CSV file"""
+    """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: '{}'"
@@ -31,7 +31,8 @@ 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"
         """
@@ -42,7 +43,7 @@ class CsvWriter:
 
     @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: str | Path = config_output
             log().info(CsvWriter._INFO_USING_PATH.format(config_output))
@@ -52,8 +53,7 @@ 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"
@@ -66,8 +66,7 @@ class CsvWriter:
                 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)
+        """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)
@@ -86,12 +85,11 @@ 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:
+            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"
@@ -100,12 +98,24 @@ class CsvWriter:
             if data is not None:
                 target_path = Path(self._output_folder, name)
                 ensure_path_exists(target_path.parent)
-                self._dataframe_to_csv(data, target_path, header=False, index=False, mode="w")
+                self.write_single_time_series_to_disk(data, target_path)
 
     @staticmethod
-    def _dataframe_to_csv(data: pd.DataFrame, file: Path, header: bool, index: bool, mode: str) -> None:
+    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"
         """
-        Write given data to specified CSV file with specified parameters using semicolon separators
+        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
@@ -135,9 +145,9 @@ 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
@@ -158,23 +168,23 @@ class CsvWriter:
         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) -> Path:
-        """Returns file path for given `agent_name` and (optional) `agent_id`"""
+        """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 path 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

@@ -16,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
@@ -29,8 +29,8 @@ class DataTransformer(ABC):
         return DataTransformer.MODES[complex_column_mode]()
 
     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`.
+        """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 columns.
         """
@@ -56,7 +56,7 @@ class DataTransformer(ABC):
     def _extract_agent_data(
         self, series: list[Output.Series], agent_type: AgentType
     ) -> 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`"""
+        """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:
@@ -66,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}
 
@@ -76,7 +76,7 @@ class DataTransformer(ABC):
         mask_simple: list[bool],
         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)
@@ -90,24 +90,24 @@ class DataTransformer(ABC):
 
     @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"""
+    """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

fameio/output/input_dao.py

@@ -16,11 +16,11 @@ from fameio.series import TimeSeriesManager, TimeSeriesError
 
 
 class InputConversionError(OutputError):
-    """Indicates an error during reconstruction of input from its protobuf representation"""
+    """Indicates an error during reconstruction of input from its protobuf representation."""
 
 
 class InputDao:
-    """Data access object for inputs saved in protobuf"""
+    """Data access object for inputs saved in protobuf."""
 
     _ERR_NO_INPUTS = "No input data found on file."
     _ERR_MULTIPLE_INPUTS = "File corrupt. More than one input section found on file."
@@ -44,8 +44,7 @@ class InputDao:
         self._timeseries_manager: TimeSeriesManager = TimeSeriesManager()
 
     def store_inputs(self, data_storages: list[DataStorage]) -> None:
-        """
-        Extracts and stores Inputs in given DataStorages - if such are present
+        """Extracts and stores Inputs in given DataStorages - if such are present.
 
         Args:
             data_storages: to be scanned for InputData
@@ -53,8 +52,7 @@ class InputDao:
         self._inputs.extend([data_storage.input for data_storage in data_storages if data_storage.HasField("input")])
 
     def recover_inputs(self) -> tuple[TimeSeriesManager, Scenario]:
-        """
-        Recovers inputs to GeneralProperties, Schema, Agents, Contracts, Timeseries
+        """Recovers inputs to GeneralProperties, Schema, Agents, Contracts, Timeseries.
 
         Return:
             recovered timeseries and scenario
@@ -76,11 +74,13 @@ class InputDao:
         return self._timeseries_manager, scenario
 
     def _get_input_data(self) -> InputData:
-        """
-        Check that exactly one previously extracted input data exist, otherwise raises an exception
+        """Check that exactly one previously extracted input data exist, otherwise raises an exception.
+
+        Returns:
+            the previously extracted input data
 
         Raises:
-            InputConversionException: if no or more than one input is present, logged with level "ERROR"
+            InputConversionException: if no input, or more than one input is present, logged with level "ERROR"
         """
         if not self._inputs:
             raise log_error(InputConversionError(self._ERR_NO_INPUTS))
@@ -90,12 +90,12 @@ class InputDao:
 
     @staticmethod
     def _get_schema(input_data: InputData) -> Schema:
-        """Read and return Schema from given `input_data`"""
+        """Read and return Schema from given `input_data`."""
         return Schema.from_string(input_data.schema)
 
     @staticmethod
     def _get_general_properties(input_data: InputData) -> GeneralProperties:
-        """Read and return GeneralProperties from given `input_data`"""
+        """Read and return GeneralProperties from given `input_data`."""
         return GeneralProperties(
             run_id=input_data.run_id,
             simulation_start_time=input_data.simulation.start_time,
@@ -105,7 +105,7 @@ class InputDao:
 
     @staticmethod
     def _get_contracts(input_data: InputData) -> list[Contract]:
-        """Read and return Contracts from given `input_data`"""
+        """Read and return Contracts from given `input_data`."""
         return [
             Contract(
                 sender_id=contract.sender_id,
@@ -120,12 +120,11 @@ class InputDao:
         ]
 
     def _init_timeseries(self, input_data: InputData) -> None:
-        """Read timeseries from given `input_data` and initialise TimeSeriesManager"""
+        """Read timeseries from given `input_data` and initialise TimeSeriesManager."""
         self._timeseries_manager.reconstruct_time_series(list(input_data.time_series))
 
     def _get_agents(self, input_data: InputData, schema: Schema) -> list[Agent]:
-        """
-        Read and return Agents from given `input_data`
+        """Read and return Agents from given `input_data`.
 
         Args:
             input_data: to read agents from
@@ -153,8 +152,7 @@ class InputDao:
         return agents
 
     def _get_attributes(self, fields: list[NestedField], schematics: dict[str, AttributeSpecs]) -> dict[str, Any]:
-        """
-        Read and return all Attributes as Dictionary from given list of fields
+        """Read and return all Attributes as Dictionary from given list of fields.
 
         Args:
             fields: data fields representing attributes
@@ -172,8 +170,7 @@ class InputDao:
         return attributes
 
     def _get_field_value(self, field: NestedField, schematic: AttributeSpecs) -> Any:
-        """
-        Extracts and returns value(s) of given `field`
+        """Extracts and returns value(s) of given `field`.
 
         Args:
             field: to extract the value(s) from