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

fameio/output/metadata/locator.py

@@ -0,0 +1,242 @@
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Locating replacement strings in complex template dictionaries."""
+
+from __future__ import annotations
+
+import re
+from abc import ABC, abstractmethod
+from typing import Any, Final
+
+from fameio.logs import log_error
+from fameio.output.metadata import MetadataCompilationError
+from fameio.tools import keys_to_lower
+
+
+class Locator(ABC):
+    """Locates replacement strings within a given template and organises their replacement."""
+
+    KEY_BASE: Final[str] = "base".lower()
+    KEY_PER_AGENT: Final[str] = "perAgent".lower()
+    KEY_PER_COLUMN: Final[str] = "perColumn".lower()
+
+    PLACEHOLDER_START: Final[str] = "<"
+    PLACEHOLDER_END: Final[str] = ">"
+    _PLACEHOLDER_PATTERN: Final[re.Pattern] = re.compile(PLACEHOLDER_START + ".*?" + PLACEHOLDER_END)
+
+    KEY_AGENT: Final[str] = "Agent".lower()
+    KEY_COLUMN: Final[str] = "Column".lower()
+
+    ITERATION_START: Final[str] = "{{"
+    ITERATION_END: Final[str] = "}}"
+    _PER_AGENT_PATTERN: Final[str] = ITERATION_START + KEY_PER_AGENT + ITERATION_END
+    _PER_COLUMN_PATTERN: Final[str] = ITERATION_START + KEY_PER_COLUMN + ITERATION_END
+
+    _ESC = "\\"
+    ITERABLE_START: Final[str] = "("
+    ITERABLE_END: Final[str] = ")"
+    _AGENT_PATTERN: Final[re.Pattern] = re.compile(
+        f"{_ESC}{ITERABLE_START}{KEY_AGENT}{_ESC}{ITERABLE_END}", re.IGNORECASE
+    )
+    _COLUMN_PATTERN: Final[re.Pattern] = re.compile(
+        f"{_ESC}{ITERABLE_START}{KEY_COLUMN}{_ESC}{ITERABLE_END}", re.IGNORECASE
+    )
+
+    _ERR_MUST_BE_DICT = "Element '{}' in metadata template must be a dictionary."
+
+    def __init__(self, agent_columns: dict[str, list[str]]) -> None:
+        """Initialise a new Locator.
+
+        Args:
+            agent_columns: agents and their output columns
+        """
+        self._agent_columns: dict = agent_columns
+        self._per_agent_template: dict = {}
+        self._per_column_template: dict = {}
+        self._current_agent: str = ""
+        self._current_column: str = ""
+
+    def locate_and_replace(self, template: dict) -> dict:
+        """Returns copy of given `template` with filled-in metadata to each placeholder - if available.
+
+        Args:
+            template: dict with placeholders to be filled
+
+        Returns:
+            template with filled in placeholders (if any)
+
+        Raises:
+            MetadataCompilationError: if template is ill-formatted, logged with level "ERROR"
+        """
+        template = keys_to_lower(template)
+        per_agent_template = template.get(self.KEY_PER_AGENT, {})
+        self._ensure_is_dict(per_agent_template, self.KEY_PER_AGENT)
+        self._per_agent_template = per_agent_template
+
+        per_column_template = template.get(self.KEY_PER_COLUMN, {})
+        self._ensure_is_dict(per_column_template, self.KEY_PER_COLUMN)
+        self._per_column_template = per_column_template
+
+        self._current_column = ""
+        self._current_agent = ""
+
+        return self._fill_dict(template.get(self.KEY_BASE, {}))
+
+    def _ensure_is_dict(self, item: Any, key: str) -> None:
+        """Raises an error if given `item` is not a dictionary.
+
+        Args:
+            item: to be tested if it is a dictionary
+            key: to be specified in error message
+
+        Raises:
+            MetadataCompilationError: if given `item` is not a dictionary, logged with level "ERROR"
+        """
+        if not isinstance(item, dict):
+            raise log_error(MetadataCompilationError(self._ERR_MUST_BE_DICT.format(key)))
+
+    def _fill_dict(self, template: dict) -> dict:
+        """Fills in metadata to each value of the given dictionary `template`.
+
+        Args:
+            template: dict with placeholders to be filled
+
+        Returns:
+            template with filled in placeholders (if any)
+        """
+        result: dict = {}
+        for key, value in template.items():
+            if isinstance(value, dict):
+                result[key] = self._fill_dict(value)
+            elif isinstance(value, list):
+                result[key] = self._fill_list(value)
+            else:
+                result[key] = self._fill_value(value)
+        return result
+
+    def _fill_list(self, values: list) -> list:
+        """Fills in metadata to each value of the given `values` list.
+
+        Args:
+            values: list of elements with potential placeholders to be filled
+
+        Returns:
+            values, potentially with filled-in placeholders
+        """
+        result: list = []
+        for value in values:
+            if isinstance(value, dict):
+                result.append(self._fill_dict(value))
+            elif isinstance(value, list):
+                result.append(self._fill_list(value))
+            else:
+                filled_value = self._fill_value(value)
+                if isinstance(filled_value, list):
+                    result.extend(filled_value)
+                else:
+                    result.append(filled_value)
+        return result
+
+    def _fill_value(self, value: str | int | float) -> Any:
+        """Checks for placeholders, iterables, or iteration template markers to replace.
+
+        Returns replacement or original value if replacement cannot be found.
+
+        Args:
+            value: to replace or return if no replacement is needed / available
+
+        Returns:
+            replacement or original value if replacement is not needed / available
+        """
+        if isinstance(value, (int, float)):
+            return value
+        if self._is_agent_replacement(value):
+            value = self._replace_agent(value)
+        if self._is_column_replacement(value):
+            value = self._replace_column(value)
+        if self._has_basic_placeholder(value):
+            return self._replace_all(value)
+        if self._is_per_column(value):
+            return self._per_column()
+        if self._is_per_agent(value):
+            return self._per_agent()
+        return value
+
+    def _has_basic_placeholder(self, value: str) -> bool:
+        """Returns true if given value contains placeholder symbols."""
+        return self.PLACEHOLDER_START in value and self.PLACEHOLDER_END in value
+
+    def _replace_all(self, value: str) -> str | Any:
+        """Replaces all placeholders in given `value` and returns the string with all replacements.
+
+        If the whole string is a single placeholder, replace it completely with the replacement content - of any type.
+        Otherwise, replace the placeholders within the string with the replacement content.
+        """
+        matches = re.findall(self._PLACEHOLDER_PATTERN, value)
+        if len(matches) == 1:
+            if re.fullmatch(self._PLACEHOLDER_PATTERN, value):
+                return self._replace(value)
+        return re.sub(self._PLACEHOLDER_PATTERN, self._callback_wrapper, value)
+
+    @abstractmethod
+    def _replace(self, data_identifier: str) -> Any | None:
+        """Returns replacement for given data identifier, or None if replacement cannot be found.
+
+        Args:
+            data_identifier: locator for the replacement data
+
+        Returns:
+            either the found replacement data (of any type), or None if no data is found
+        """
+
+    def _callback_wrapper(self, match: re.Match) -> str:
+        """Extracts replacement string from given match and calls for its replacement."""
+        return str(self._replace(match.group(0)))
+
+    def _is_agent_replacement(self, value: str) -> bool:
+        """Returns true if given value contains placeholder and agent iterable placeholder."""
+        return re.search(self._AGENT_PATTERN, value) is not None
+
+    def _replace_agent(self, value) -> str:
+        """Replace all occurrences of agent iterable pattern in given string."""
+        return re.sub(self._AGENT_PATTERN, str(self._current_agent), value)
+
+    def _is_column_replacement(self, value: str) -> bool:
+        """Returns true if given value contains placeholder and agent iterable placeholder."""
+        return re.search(self._COLUMN_PATTERN, value) is not None
+
+    def _replace_column(self, value) -> str:
+        """Replace all occurrences of column iterable pattern in given string."""
+        return re.sub(self._COLUMN_PATTERN, str(self._current_column), value)
+
+    def _is_per_column(self, value: str) -> bool:
+        """Returns true if given value is the 'perColumn' section."""
+        return value.strip().lower() == self._PER_COLUMN_PATTERN
+
+    def _per_column(self) -> list:
+        """Returns list of metadata for all columns of current agent."""
+        column_metadata = []
+        if len(self._per_column_template) > 0:
+            for column in self._agent_columns[self._current_agent]:
+                template = self._per_column_template
+                self._current_column = column
+                column_metadata.append(self._fill_dict(template))
+        return column_metadata
+
+    def _is_per_agent(self, value: str) -> bool:
+        """Returns true if given value is the 'perAgent' section."""
+        return value.strip().lower() == self._PER_AGENT_PATTERN
+
+    def _per_agent(self) -> list:
+        """Returns list of metadata for all agents.
+
+        Returns empty list if either the per-agent template is missing, or no agents are registered for output.
+        """
+        agent_metadata = []
+        if len(self._per_agent_template) > 0:
+            for agent in self._agent_columns.keys():
+                template = self._per_agent_template
+                self._current_agent = agent
+                agent_metadata.append(self._fill_dict(template))
+        return agent_metadata

fameio/output/metadata/oeo_template.py

@@ -0,0 +1,93 @@
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+OEO_TEMPLATE = {
+    "base": {
+        "@context": "https://raw.githubusercontent.com/OpenEnergyPlatform/oemetadata/production/oemetadata/latest/context.json",
+        "name": "<schema:metadata:name>_result_metadata",
+        "title": "Results for <schema:metadata:name> run <scenario:metadata:RunId>.",
+        "description": """Input compiled with FAME-Io <execution:InputCompilation:SoftwareVersions:FameIo>.
+        Simulated by FAME-Core <execution:ModelRun:SoftwareVersions:FameCore>.
+        Extracted by FAME-Io <execution:OutputExtraction:SoftwareVersions:FameIo>.""",
+        "resources": ["{{perAgent}}"],
+        "metaMetadata": {
+            "metadataVersion": "OEMetadata-2.0.4",
+            "metadataLicense": {
+                "name": "CC0-1.0",
+                "title": "Creative Commons Zero v1.0 Universal",
+                "path": "https://creativecommons.org/publicdomain/zero/1.0",
+            },
+        },
+    },
+    "perAgent": {
+        "name": "(agent).*.csv",
+        "topics": [],
+        "title": "Results for (agent)",
+        "path": "./(agent).*.csv",
+        "description": "Simulation outputs by simulated time of agent type '(agent)'",
+        "languages": ["en-GB"],
+        "subject": "<schema:AgentTypes:(agent):metadata:subject>",
+        "keywords": "<schema:AgentTypes:(agent):metadata:keywords>",
+        "publicationDate": "<scenario:metadata:output:publicationDate>",
+        "embargoPeriod": "<scenario:metadata:output:embargoPeriod>",
+        "context": {
+            "title": "<schema:metadata:title>",
+            "homepage": "<schema:metadata:homepage>",
+            "documentation": "<schema:metadata:documentation>",
+            "sourceCode": "<schema:metadata:sourceCode>",
+            "publisher": "<schema:metadata:publisher>",
+            "publisherLogo": "<schema:metadata:publisherLogo>",
+            "contact": "<schema:metadata:contact>",
+            "fundingAgency": "<schema:metadata:fundingAgency>",
+            "fundingAgencyLogo": "<schema:metadata:fundingAgencyLogo>",
+            "grantNo": "<schema:metadata:grantNo>",
+        },
+        "spatial": {},
+        "temporal": {},
+        "sources": [],
+        "licenses": "<scenario:metadata:output:licenses>",
+        "contributors": "<schema:metadata:contributors>",
+        "type": "table",
+        "format": "CSV",
+        "encoding": "UTF-8",
+        "schema": {
+            "fields": [
+                {
+                    "name": "AgentId",
+                    "description": "Unique ID of the agent in the simulation",
+                    "type": "integer",
+                    "nullable": False,
+                    "unit": "n/a",
+                    "isAbout": [],
+                    "valueReference": [],
+                },
+                {
+                    "name": "TimeStep",
+                    "description": "Simulated time these values are associated with",
+                    "type": "integer or time stamp",
+                    "nullable": False,
+                    "unit": "n/a",
+                    "isAbout": [
+                        {"name": "TimeStamp", "@id": "https://openenergyplatform.org/ontology/oeo/OEO_00140043"}
+                    ],
+                    "valueReference": [],
+                },
+                "{{perColumn}}",
+            ],
+            "primaryKey": ["AgentId", "TimeStep"],
+            "foreignKeys": [],
+            "dialect": {"delimiter": ";", "decimalSeparator": "."},
+            "review": {},
+        },
+    },
+    "perColumn": {
+        "name": "(column)",
+        "description": "<schema:AgentTypes:(agent):outputs:(column):metadata:description>",
+        "type": "decimal",
+        "nullable": True,
+        "unit": "<schema:AgentTypes:(agent):outputs:(column):metadata:unit>",
+        "isAbout": "<schema:AgentTypes:(agent):outputs:(column):metadata:isAbout>",
+        "valueReference": "<schema:AgentTypes:(agent):outputs:(column):metadata:valueReference>",
+    },
+}

fameio/output/metadata/template_reader.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Reading of metadata templates in YAML or JSON format."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fameio.input import YamlLoaderError
+from fameio.input.loader import ALLOWED_SUFFIXES as YAML_SUFFIXES, load_yaml
+from fameio.logs import log_error
+from fameio.output.metadata import MetadataCompilationError
+
+JSON_SUFFIX: str = ".json"
+ENCODING = "UTF-8"
+
+_ERR_UNKNOWN_ENDING = "Template file ending '{}' corresponds neither to a JSON or YAML file."
+_ERR_READING_FILE = "Could not read template file: '{}'"
+
+
+def read_template_file(file: Path) -> dict:
+    """Reads and returns metadata template `file` encoded in UTF-8.
+
+    Args:
+        file: to be read
+
+    Returns:
+        dictionary content of the file
+
+    Raises:
+        MetadataCompilationError: if template file has unknown type, could not be opened/read, logged with level "ERROR"
+    """
+    file_ending = file.suffix.lower()
+    if _has_yaml_ending(file_ending) or _has_json_ending(file_ending):
+        return _read_yaml(file)
+    raise log_error(MetadataCompilationError(_ERR_UNKNOWN_ENDING.format(file_ending)))
+
+
+def _has_yaml_ending(file_ending: str) -> bool:
+    """Returns True if `file_ending` corresponds to a YAML file."""
+    return file_ending in YAML_SUFFIXES
+
+
+def _has_json_ending(file_ending: str) -> bool:
+    """Returns True if `file_ending` corresponds to a JSON file."""
+    return file_ending == JSON_SUFFIX
+
+
+def _read_yaml(file: Path) -> dict:
+    """Returns content of the provided yaml file
+
+    Args:
+        file: to be opened and read
+
+    Returns:
+        file content as dict
+
+    Raises:
+        MetadataCompilationError: if file could not be opened or read, logged with level "ERROR"
+    """
+    try:
+        return load_yaml(file, encoding=ENCODING)
+    except YamlLoaderError as e:
+        raise log_error(MetadataCompilationError(_ERR_READING_FILE.format(file))) from e

fameio/output/output_dao.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+"""Accessing output content of protobuf messages."""
+
 from __future__ import annotations
 
 from typing import Iterable

fameio/output/reader.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+"""Reading of protobuf files."""
 from __future__ import annotations
 
 import struct

fameio/output/yaml_writer.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+"""Writing of data to YAML files."""
+
 from pathlib import Path
 
 import yaml
@@ -8,7 +10,7 @@ import yaml
 from fameio.logs import log, log_error
 from fameio.output import OutputError
 
-_ERR_OPEN_FILE = "Could not open file for reading: '{}'"
+_ERR_OPEN_FILE = "Could not open file for writing: '{}'"
 
 _INFO_DESTINATION = "Saving scenario to file at {}"
 

fameio/scripts/REUSE.toml

@@ -0,0 +1,6 @@
+version = 1
+
+[[annotations]]
+path = ["*.py"]
+SPDX-FileCopyrightText = "2025 German Aerospace Center <fame@dlr.de>"
+SPDX-License-Identifier = "Apache-2.0"

fameio/scripts/__init__.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+"""Main scripts callable from command line."""
 import sys
 
 from fameio.scripts.convert_results import DEFAULT_CONFIG as DEFAULT_CONVERT_CONFIG
@@ -13,6 +14,7 @@ from fameio.cli.reformat import handle_args as handle_reformat_args
 
 # noinspection PyPep8Naming
 def makeFameRunConfig():
+    """Compiles FAME simulation input files in protobuf format."""
     cli_config = handle_make_config_args(sys.argv[1:])
     try:
         make_config(cli_config)
@@ -22,6 +24,7 @@ def makeFameRunConfig():
 
 # noinspection PyPep8Naming
 def convertFameResults():
+    """Converts a protobuf file to human-readable outputs."""
     cli_config = handle_convert_results_args(sys.argv[1:], DEFAULT_CONVERT_CONFIG)
     try:
         convert_results(cli_config)
@@ -31,6 +34,7 @@ def convertFameResults():
 
 # noinspection PyPep8Naming
 def reformatTimeSeries():
+    """Reformats a timeseries file to speed up its future usage in scenarios."""
     cli_config = handle_reformat_args(sys.argv[1:])
     try:
         reformat(cli_config)

fameio/scripts/convert_results.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import sys
 from pathlib import Path
-from typing import Any, BinaryIO
+from typing import Any, BinaryIO, Optional
 
 import pandas as pd
 
@@ -18,7 +18,17 @@ from fameio.output.conversion import apply_time_option, apply_time_merging
 from fameio.output.csv_writer import CsvWriter
 from fameio.output.data_transformer import DataTransformer, INDEX
 from fameio.output.execution_dao import ExecutionDao
+from fameio.output.files import (
+    get_output_folder_name,
+    create_output_folder,
+    RECOVERED_INPUT_PATH,
+    RECOVERED_SCENARIO_PATH,
+)
 from fameio.output.input_dao import InputDao
+from fameio.output.metadata.compiler import MetadataCompiler
+from fameio.output.metadata.json_writer import data_to_json_file
+from fameio.output.metadata.oeo_template import OEO_TEMPLATE
+from fameio.output.metadata.template_reader import read_template_file
 from fameio.output.output_dao import OutputDAO
 from fameio.output.reader import Reader
 from fameio.output.yaml_writer import data_to_yaml_file
@@ -65,7 +75,10 @@ def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO,
         OutputError: if file could not be opened or converted, logged with level "ERROR"
     """
     log().info("Reading and extracting data...")
-    output_writer = CsvWriter(config[Options.OUTPUT], file_path, config[Options.SINGLE_AGENT_EXPORT])
+    output_path = get_output_folder_name(config[Options.OUTPUT], file_path)
+    create_output_folder(output_path)
+
+    output_writer = CsvWriter(output_path, config[Options.SINGLE_AGENT_EXPORT])
     agent_type_log = AgentTypeLog(_agent_name_filter_list=config[Options.AGENT_LIST])
     data_transformer = DataTransformer.build(config[Options.RESOLVE_COMPLEX_FIELD])
     reader = Reader.get_reader(file=file_stream, read_single=config[Options.MEMORY_SAVING])
@@ -73,7 +86,7 @@ def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO,
     execution_dao = ExecutionDao()
     while data_storages := reader.read():
         execution_dao.store_execution_metadata(data_storages)
-        if config[Options.INPUT_RECOVERY]:
+        if config[Options.INPUT_RECOVERY] or config[Options.METADATA]:
             input_dao.store_inputs(data_storages)
         output = OutputDAO(data_storages, agent_type_log)
         for agent_name in output.get_sorted_agents_to_extract():
@@ -86,7 +99,7 @@ def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO,
             output_writer.write_to_files(agent_name, data_frames)
 
     if config[Options.INPUT_RECOVERY]:
-        _recover_inputs(config, input_dao, execution_dao.get_fameio_version())
+        _recover_inputs(output_path, input_dao, execution_dao.get_fameio_version())
     if config[Options.MEMORY_SAVING]:
         _memory_saving_apply_conversions(config, output_writer)
 
@@ -95,14 +108,21 @@ def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO,
             log().warning(_WARN_OUTPUT_SUPPRESSED.format(agent_type_log.get_agents_with_output()))
         else:
             log().warning(_WARN_OUTPUT_MISSING)
+    elif config[Options.METADATA]:
+        compiler = MetadataCompiler(
+            input_data=input_dao.get_input_data(),
+            execution_data=execution_dao.get_metadata_dict(),
+            agent_columns=agent_type_log.get_agent_columns(),
+        )
+        write_metadata(output_path, config[Options.METADATA_TEMPLATE], compiler)
     log().info("Data conversion completed.")
 
 
-def _recover_inputs(config: dict[Options, Any], input_dao: InputDao, fameio_version: str) -> None:
+def _recover_inputs(output_path: Path, input_dao: InputDao, fameio_version: str) -> None:
     """Reads scenario configuration from provided `input_dao`.
 
     Args:
-        config: script configuration options
+        output_path: path to output files
         input_dao: to recover the input data from
         fameio_version: version of fameio that was used to create the input data
 
@@ -114,12 +134,10 @@ def _recover_inputs(config: dict[Options, Any], input_dao: InputDao, fameio_vers
         timeseries, scenario = input_dao.recover_inputs()
     except InputError as ex:
         raise log_error(OutputError(_ERR_RECOVER_INPUT.format(fameio_version))) from ex
-    base_path = config[Options.OUTPUT] if config[Options.OUTPUT] is not None else "./"
-    series_writer = CsvWriter(
-        config_output=Path(base_path, "./recovered"), input_file_path=Path("./"), single_export=False
-    )
+
+    series_writer = CsvWriter(output_folder=Path(output_path, RECOVERED_INPUT_PATH), single_export=False)
     series_writer.write_all_time_series_to_disk(timeseries)
-    data_to_yaml_file(scenario.to_dict(), Path(base_path, "./recovered/scenario.yaml"))
+    data_to_yaml_file(scenario.to_dict(), Path(output_path, RECOVERED_SCENARIO_PATH))
 
 
 def _memory_saving_apply_conversions(config: dict[Options, Any], output_writer: CsvWriter) -> None:
@@ -143,8 +161,24 @@ def _memory_saving_apply_conversions(config: dict[Options, Any], output_writer:
         output_writer.write_to_files(agent_name, parsed_data)
 
 
+def write_metadata(output_path: Path, template_file: Optional[Path], compiler: MetadataCompiler):
+    """Reads metadata templates, fills in available metadata, and writes output to a JSON file.
+
+    Args:
+        output_path: path to output folder
+        template_file: path to metadata template (None allowed)
+        compiler: to compile metadata with
+
+    Raises:
+        OutputError: in case templates could not be read or filled-in, or JSON writing failed, logged with level "ERROR"
+    """
+    template = OEO_TEMPLATE if template_file is None else read_template_file(template_file)
+    output_metadata = compiler.locate_and_replace(template)
+    data_to_json_file(output_metadata, output_path)
+
+
 def run(config: dict[Options, Any] | None = None) -> None:
-    """Reads configured file in protobuf format and extracts its content to .CSV and .YAML file(s).
+    """Reads configured file in protobuf format and extracts its content to CSV and YAML file(s).
 
     Args:
         config: script configuration options

fameio/scripts/exception.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+"""Defines exceptions on the script level."""
 
 
 class ScriptError(Exception):

fameio/scripts/reformat.py

@@ -19,6 +19,7 @@ FILE_NAME_APPENDIX = "_reformatted"
 _ERR_FAIL = "Timeseries reformatting script failed."
 _ERR_NO_FILES = "No file found matching this pattern: '{}'"
 _ERR_FILE_CONVERSION = "Could not reformat file: '{}'"
+_ERR_FILES_FAILED = "Could not reformat these files: '{}'"
 
 
 def reformat_file(file: Path, replace: bool) -> None:
@@ -58,9 +59,32 @@ def run(config: dict[Options, Any] | None = None) -> None:
         raise log_error(ScriptError(_ERR_NO_FILES.format(config[Options.FILE_PATTERN]))) from ex
     if not files:
         raise log_error(ScriptError(_ERR_NO_FILES.format(config[Options.FILE_PATTERN])))
+
+    erroneous_files = reformat_files(files, config[Options.REPLACE])
+    if len(erroneous_files) > 0:
+        log_error(ScriptError(_ERR_FILES_FAILED.format(erroneous_files)))
+    else:
+        log_and_print("All files reformatted.")
+
+
+def reformat_files(files: list[Path], replace: bool) -> list[str]:
+    """Reformats given files and potentially replaces them.
+
+    Args:
+        files: list of files to be reformatted
+        replace: if true, original files are replaced
+
+    Returns:
+        list of files that could not be reformatted
+    """
+    erroneous_files: list[str] = []
     for file in files:
         log_and_print(f"Reformatting file: {file}")
-        reformat_file(file, config[Options.REPLACE])
+        try:
+            reformat_file(file, replace)
+        except ScriptError:
+            erroneous_files.append(file.as_posix())
+    return erroneous_files
 
 
 if __name__ == "__main__":