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

fameio/input/loader/controller.py

@@ -31,7 +31,7 @@ class LoaderController:
     NODE_SPLIT_STRING: Final[str] = ":"
 
     _ERR_FILE_OPEN_ERROR = "Could not open file: '{}'"
-    _ERR_FILE_LOAD_ERROR = "Could not parse YAML file due to errors in (line:column): ({}:{})"
+    _ERR_FILE_LOAD_ERROR = "Could not parse file '{}' due to error in (line:column): ({}:{})"
     _ERR_NODE_MISSING = "'!include_node [{}, {}]': Cannot find '{}'"
     _ERR_NOT_LIST = "!include can only combine list-like elements from multiple files!"
     _WARN_NOTHING_TO_INCLUDE = "Could not find any files matching this '!include' directive '{}'"
@@ -51,11 +51,11 @@ class LoaderController:
         self._path_resolver = path_resolver
         self._encoding: str | None = encoding
 
-    def load(self, yaml_file_path: Path) -> dict:
+    def load(self, file_path: Path) -> dict:
         """Spawns a new FameYamlLoader, loads the given `yaml_file_path` and returns its content.
 
         Args:
-            yaml_file_path: path to YAML file that is to be loaded
+            file_path: path to YAML file that is to be loaded
 
         Returns:
             dictionary representation of loaded file
@@ -64,14 +64,16 @@ class LoaderController:
             YamlLoaderError: if file could not be read, logged with level "CRITICAL"
         """
         try:
-            with open(yaml_file_path, "r", encoding=self._encoding) as configfile:
+            with open(file_path, "r", encoding=self._encoding) as configfile:
                 try:
                     data = yaml.load(configfile, self._spawn_loader_builder())  # type: ignore[arg-type]
                 except yaml.YAMLError as e:
                     line, column = self._get_problem_position(e)
-                    raise log_critical(YamlLoaderError(self._ERR_FILE_LOAD_ERROR.format(line, column))) from e
+                    raise log_critical(
+                        YamlLoaderError(self._ERR_FILE_LOAD_ERROR.format(file_path, line, column))
+                    ) from e
         except OSError as e:
-            raise log_critical(YamlLoaderError(self._ERR_FILE_OPEN_ERROR.format(yaml_file_path))) from e
+            raise log_critical(YamlLoaderError(self._ERR_FILE_OPEN_ERROR.format(file_path))) from e
         return data
 
     @staticmethod

fameio/input/scenario/scenario.py

@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-from typing import Final, Any
+from typing import Final, Any, Optional
 
 from fameio.input import SchemaError
 from fameio.input.metadata import Metadata
@@ -34,8 +34,8 @@ class Scenario(Metadata):
     _ERR_MULTI_CONTRACT = "Could not create scenario: Definition of Contracts has errors: {}"
     _ERR_CONTRACT = "Could not create scenario: Definition of Contract has errors: {}"
 
-    def __init__(self, schema: Schema, general_props: GeneralProperties) -> None:
-        super().__init__()
+    def __init__(self, schema: Schema, general_props: GeneralProperties, metadata: Optional[dict] = None) -> None:
+        super().__init__({Metadata.KEY_METADATA: metadata})
         self._schema = schema
         self._general_props = general_props
         self._string_sets: dict[str, StringSet] = {}

fameio/output/agent_type.py

@@ -77,24 +77,22 @@ class AgentTypeLog:
         self._agents_with_output: list[str] = []
 
     def update_agents(self, new_types: dict[str, Output.AgentType]) -> None:
-        """Saves `new_types` if they are requested for extraction.
+        """Saves new types of agents for later inspection.
 
-        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.
+        If any new agent types are provided, registers them as "agents with output"
+        Then, checks if they are requested for extraction, and, if so, saves them as "requested agent types".
 
         Args:
-            new_types: to be saved (if requested for extraction)
+            new_types: to be logged
 
         Raises:
             AgentTypeError: if agent type was already registered, logged with level "ERROR"
         """
-        if not new_types:
-            return
-
-        self._agents_with_output.extend(list(new_types.keys()))
-        filtered_types = self._filter_agents_by_name(new_types)
-        self._ensure_no_duplication(filtered_types)
-        self._requested_agent_types.update(filtered_types)
+        if new_types is not None and len(new_types) > 0:
+            self._agents_with_output.extend(list(new_types.keys()))
+            filtered_types = self._filter_agents_by_name(new_types)
+            self._ensure_no_duplication(filtered_types)
+            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`.
@@ -127,7 +125,7 @@ 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."""
         return len(self._requested_agent_types) > 0
 
     def get_agent_type(self, agent_type_name: str) -> AgentType:
@@ -155,13 +153,13 @@ class AgentTypeLog:
         return self._agents_with_output
 
     def get_agent_columns(self) -> dict[str, list[str]]:
-        """Returns all agents with output mapped to their simple output columns.
+        """Returns all agents that were not filtered, with their output mapped to their simple output columns.
 
         Raises:
             AgentTypeError: if - somehow - an agent type is not registered but has data, logged with level "ERROR"
         """
         result = {}
-        for agent in self.get_agents_with_output():
-            agent_type = self.get_agent_type(agent)
-            result[agent] = list(agent_type.get_simple_column_map().values())
+        for agent_name in self._requested_agent_types:
+            agent_type = self.get_agent_type(agent_name)
+            result[agent_name] = list(agent_type.get_simple_column_map().values())
         return result

fameio/output/csv_writer.py

@@ -9,7 +9,7 @@ from pathlib import Path
 
 import pandas as pd
 
-from fameio.logs import log, log_error
+from fameio.logs import log_error
 from fameio.output import OutputError
 from fameio.output.data_transformer import INDEX
 from fameio.series import TimeSeriesManager
@@ -23,49 +23,21 @@ class CsvWriterError(OutputError):
 class CsvWriter:
     """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: {}"
-
     CSV_FILE_SUFFIX = ".csv"
 
-    def __init__(self, config_output: Path, input_file_path: Path, single_export: bool) -> None:
+    def __init__(self, output_folder: Path, single_export: bool) -> None:
         """Constructs a new CsvWriter.
 
-        Raises:
-             CsvWriterError: if output folder could not be created, logged with level "ERROR"
+        Args:
+            output_folder: to write the output files to
+            single_export: if true, one output file per unique agent is created
         """
         self._single_export = single_export
-        self._output_folder = self._get_output_folder_name(config_output, input_file_path)
+        self._output_folder = output_folder
         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`."""
-        if 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
-            log().info(CsvWriter._INFO_USING_DERIVED_PATH.format(output_folder_name))
-        return Path(output_folder_name)
-
-    def _create_output_folder(self) -> None:
-        """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():
-            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).

fameio/output/files.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Finding output folders and files, creating the output folder."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Final, Optional
+
+from fameio.logs import log, log_error
+from fameio.output import OutputError
+
+_ERR_DIR_CREATE = "Could not create directory for output files: '{}'"
+
+_INFO_USING_PATH = "Using specified output path: '{}'"
+_INFO_USING_DERIVED_PATH = "No output path specified - writing to new local folder: '{}'"
+
+_DEBUG_NEW_FOLDER = "Output folder '{}' not present, trying to create it..."
+_DEBUG_EXISTING_FOLDER = "Output folder '{}' already exists..."
+
+RECOVERED_INPUT_PATH: Final[str] = "./recovered"
+RECOVERED_SCENARIO_PATH: Final[str] = "./recovered/scenario.yaml"
+METADATA_FILE_NAME: Final[str] = "metadata.json"
+
+
+class OutputPathError(OutputError):
+    """An error that occurred during creation of the output path."""
+
+
+def get_output_folder_name(config_output: Optional[Path | str], input_file_path: Path) -> 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
+        log().info(_INFO_USING_PATH.format(config_output))
+    else:
+        output_folder_name = input_file_path.stem
+        log().info(_INFO_USING_DERIVED_PATH.format(output_folder_name))
+    return Path(output_folder_name)
+
+
+def create_output_folder(output_path: Path) -> None:
+    """Creates output folder if not yet present.
+
+    Raises:
+        OutputPathError: if output folder could not be created, logged with level "ERROR"
+    """
+    if not output_path.is_dir():
+        log().debug(_DEBUG_NEW_FOLDER.format(output_path))
+        try:
+            output_path.mkdir(parents=True)
+        except OSError as e:
+            raise log_error(OutputPathError(_ERR_DIR_CREATE.format(output_path))) from e
+    else:
+        log().debug(_DEBUG_EXISTING_FOLDER.format(output_path))

fameio/output/input_dao.py

@@ -4,15 +4,15 @@
 """Accessing input content of protobuf messages."""
 
 import ast
-from typing import Any
+from typing import Any, Optional
 
 from fameprotobuf.data_storage_pb2 import DataStorage
 from fameprotobuf.field_pb2 import NestedField
 from fameprotobuf.input_file_pb2 import InputData
 
-from fameio.input.scenario import GeneralProperties, Agent, Contract, Scenario
+from fameio.input.scenario import GeneralProperties, Agent, Contract, Scenario, StringSet, Attribute
 from fameio.input.schema import Schema, AttributeSpecs, AttributeType
-from fameio.logs import log_error
+from fameio.logs import log_error, log
 from fameio.output import OutputError
 from fameio.series import TimeSeriesManager, TimeSeriesError
 
@@ -28,6 +28,8 @@ class InputDao:
     _ERR_MULTIPLE_INPUTS = "File corrupt. More than one input section found on file."
     _ERR_NO_SCHEMA = "No schema found on file - cannot recover inputs."
     _ERR_SERIES_MISSING = "References time series '{}' was not registered on file."
+    _ERR_SCENARIO_METADATA = "Proceeding without metadata for scenario - could not be extracted due to: {}"
+    _ERR_STRING_SET_METADATA = "Proceeding without metadata for string set '{}' - could not be extracted due to: {}"
 
     _FIELD_NAME_MAP: dict = {
         AttributeType.STRING: "string_values",
@@ -65,7 +67,8 @@ class InputDao:
         """
         input_data = self.get_input_data()
         schema = self._get_schema(input_data)
-        scenario = Scenario(schema, self._get_general_properties(input_data))
+        metadata = self._metadata_to_dict(input_data.metadata)
+        scenario = Scenario(schema, self._get_general_properties(input_data), metadata)
         for contract in self._get_contracts(input_data):
             scenario.add_contract(contract)
 
@@ -73,6 +76,9 @@ class InputDao:
         for agent in self._get_agents(input_data, schema):
             scenario.add_agent(agent)
 
+        for name, string_set in self._get_string_sets(input_data).items():
+            scenario.add_string_set(name, string_set)
+
         return self._timeseries_manager, scenario
 
     def get_input_data(self) -> InputData:
@@ -95,6 +101,16 @@ class InputDao:
         """Read and return Schema from given `input_data`."""
         return Schema.from_string(input_data.schema)
 
+    @staticmethod
+    def _metadata_to_dict(metadata: Optional[str] = None) -> dict:
+        """Convert given metadata `metadata to dict`, proceeds on error but logs given `message`"""
+        if metadata:
+            try:
+                return ast.literal_eval(metadata)
+            except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError) as e:
+                log().error(InputDao._ERR_SCENARIO_METADATA.format(e))
+        return {}
+
     @staticmethod
     def _get_general_properties(input_data: InputData) -> GeneralProperties:
         """Read and return GeneralProperties from given `input_data`."""
@@ -121,6 +137,20 @@ class InputDao:
             for contract in input_data.contracts
         ]
 
+    @staticmethod
+    def _get_string_sets(input_data: InputData) -> dict[str, StringSet]:
+        """Read and return StringSets from given `input_data`."""
+        string_sets = {}
+        for dao in input_data.string_sets:
+            values = {
+                entry.name: {StringSet.KEY_METADATA: InputDao._metadata_to_dict(entry.metadata)} for entry in dao.values
+            }
+            metadata = InputDao._metadata_to_dict(dao.metadata)
+            string_sets[dao.name] = StringSet.from_dict(
+                {StringSet.KEY_VALUES: values, StringSet.KEY_METADATA: metadata}
+            )
+        return string_sets
+
     def _init_timeseries(self, input_data: InputData) -> None:
         """Read timeseries from given `input_data` and initialise TimeSeriesManager."""
         self._timeseries_manager.reconstruct_time_series(list(input_data.time_series))
@@ -146,14 +176,14 @@ class InputDao:
                 type_name=agent_dao.class_name,
                 metadata=ast.literal_eval(agent_dao.metadata) if agent_dao.metadata else None,
             )
-            attribute_dict = self._get_attributes(
+            attributes_dict = self._get_attributes_dict(
                 list(agent_dao.fields), schema.agent_types[agent_dao.class_name].attributes
             )
-            agent.init_attributes_from_dict(attribute_dict)
+            agent.init_attributes_from_dict(attributes_dict)
             agents.append(agent)
         return agents
 
-    def _get_attributes(self, fields: list[NestedField], schematics: dict[str, AttributeSpecs]) -> dict[str, Any]:
+    def _get_attributes_dict(self, fields: list[NestedField], schematics: dict[str, AttributeSpecs]) -> dict[str, dict]:
         """Read and return all Attributes as Dictionary from given list of fields.
 
         Args:
@@ -161,14 +191,15 @@ class InputDao:
             schematics: description of the attributes associated by name
 
         Returns:
-            all recovered attributes and their associated values
+            all recovered attributes and their associated values as dictionary
 
         Raises:
             InputConversionError: if attributes could not be reconstructed, logged with level "ERROR"
         """
-        attributes: dict[str, Any] = {}
+        attributes: dict[str, dict[str, Any]] = {}
         for field in fields:
-            attributes[field.field_name] = self._get_field_value(field, schematics[field.field_name])
+            value = self._get_field_value(field, schematics[field.field_name])
+            attributes[field.field_name] = value if not field.metadata else self._get_field_dict(value, field.metadata)
         return attributes
 
     def _get_field_value(self, field: NestedField, schematic: AttributeSpecs) -> Any:
@@ -192,9 +223,20 @@ class InputDao:
                 raise log_error(InputConversionError(self._ERR_SERIES_MISSING.format(field.series_id))) from e
         if attribute_type is AttributeType.BLOCK:
             if schematic.is_list:
-                return [self._get_attributes(list(entry.fields), schematic.nested_attributes) for entry in field.fields]
-            return self._get_attributes(list(field.fields), schematic.nested_attributes)
+                return [
+                    self._get_attributes_dict(list(entry.fields), schematic.nested_attributes) for entry in field.fields
+                ]
+            return self._get_attributes_dict(list(field.fields), schematic.nested_attributes)
         value = getattr(field, self._FIELD_NAME_MAP[attribute_type])
         if schematic.is_list:
             return list(value)
         return list(value)[0]
+
+    def _get_field_dict(self, field_value: Any, metadata: str) -> dict[str, Any]:
+        """Returns dict with metadata and `field_value` associated with either singular or plural key, if is list."""
+        result: dict[str, Any] = {Attribute.KEY_METADATA: self._metadata_to_dict(metadata)}
+        if isinstance(field_value, list):
+            result[Attribute.KEY_VALUES] = field_value
+        else:
+            result[Attribute.KEY_VALUE] = field_value
+        return result

fameio/output/metadata/json_writer.py

@@ -8,8 +8,7 @@ from pathlib import Path
 
 from fameio.logs import log, log_error
 from fameio.output import OutputError
-
-METADATA_FILE_NAME = "metadata.json"
+from fameio.output.files import METADATA_FILE_NAME
 
 _ERR_OPEN_FILE = "Could not open file for writing: '{}'"
 _INFO_DESTINATION = "Saving JSON to file to {}"

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/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,6 +18,12 @@ 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
@@ -69,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])
@@ -90,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)
 
@@ -100,15 +109,20 @@ def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO,
         else:
             log().warning(_WARN_OUTPUT_MISSING)
     elif config[Options.METADATA]:
-        write_metadata(config, input_dao, execution_dao, agent_type_log)
+        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
 
@@ -120,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:
@@ -149,31 +161,20 @@ def _memory_saving_apply_conversions(config: dict[Options, Any], output_writer:
         output_writer.write_to_files(agent_name, parsed_data)
 
 
-def write_metadata(
-    config: dict[Options, Any], input_dao: InputDao, execution_dao: ExecutionDao, agent_type_log: AgentTypeLog
-):
+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:
-        config: to determined metadata template, and output path
-        input_dao: contains input data
-        execution_dao: contains execution metadata
-        agent_type_log: contains log about which agent output was created
+        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"
     """
-    compiler = MetadataCompiler(
-        input_data=input_dao.get_input_data(),
-        execution_data=execution_dao.get_metadata_dict(),
-        agent_columns=agent_type_log.get_agent_columns(),
-    )
-
-    template_file = config[Options.METADATA_TEMPLATE]
     template = OEO_TEMPLATE if template_file is None else read_template_file(template_file)
-    metadata = compiler.locate_and_replace(template)
-    base_path = config[Options.OUTPUT] if config[Options.OUTPUT] is not None else Path(".")
-    data_to_json_file(metadata, base_path)
+    output_metadata = compiler.locate_and_replace(template)
+    data_to_json_file(output_metadata, output_path)
 
 
 def run(config: dict[Options, Any] | None = None) -> None:

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__":

fameio/series.py

@@ -13,6 +13,7 @@ from typing import Any
 import pandas as pd
 from fameprotobuf.input_file_pb2 import InputData
 from google.protobuf.internal.wire_format import INT64_MIN, INT64_MAX
+from pandas.errors import EmptyDataError, ParserError
 
 from fameio.input import InputError
 from fameio.input.resolver import PathResolver
@@ -141,7 +142,7 @@ class TimeSeriesManager:
         """
         try:
             return pd.read_csv(file, sep=";", header=None, comment="#")
-        except OSError as e:
+        except (OSError, EmptyDataError, ParserError) as e:
             raise log_error(TimeSeriesError(e)) from e
 
     @staticmethod

{fameio-3.5.0.dist-info → fameio-3.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fameio
-Version: 3.5.0
+Version: 3.5.1
 Summary: Tools for input preparation and output digestion of FAME models
 License: Apache-2.0
 Keywords: FAME,fameio,agent-based modelling,energy systems

{fameio-3.5.0.dist-info → fameio-3.5.1.dist-info}/RECORD

@@ -7,7 +7,7 @@ fameio/cli/parser.py,sha256=Ux_SW13y4UhfAEfe02qnODSFVBjW_lndPCSqqp2Prm0,11357
 fameio/cli/reformat.py,sha256=hnVsUyyMly3GN4TShl1QCVvb2w1d5gGgbUJUOWyN3Hw,2288
 fameio/input/__init__.py,sha256=UcBQmK24luQzLUXNaYiJBZcCmYiy8cF2RtM0RJ-Qr9w,615
 fameio/input/loader/__init__.py,sha256=YlxCAEJnORf6Dbab__m1Qr3ZOM55XvtczgFicO-erzc,2812
-fameio/input/loader/controller.py,sha256=-azfGvOiEmMKpRzYFpEjiMcsLrAGbuXK_auPqSLiE3I,8182
+fameio/input/loader/controller.py,sha256=QacBjHH7oILviq3hP9Z_WIfZW1Ki5yaAmkJqLlIZowQ,8220
 fameio/input/loader/loader.py,sha256=CZxvbdwyPVOogKunH6vUn-OXxNLCCGqVoTqK4rWBKmg,5397
 fameio/input/metadata.py,sha256=VB96o-MMi6WPtzLSM9P0Lrdn0VC6zClXziWrbuovjsk,6638
 fameio/input/resolver.py,sha256=ZJnVICipcMSHp1KYXLeK-nZBXIFQBjmPh3V1Vvqb6nk,1936
@@ -18,7 +18,7 @@ fameio/input/scenario/contract.py,sha256=zMxJag_1pQwgthMCDxabmyqrSBKXd4Xpa60e-C5
 fameio/input/scenario/exception.py,sha256=VFo9wP7J9W0wx_S7ynnTsIcobVB4H82iklH1jUob7to,1998
 fameio/input/scenario/fameiofactory.py,sha256=xjc1s1FTwbnS84pheqcGNllOJsN1fs7--J36RKO7VYI,2854
 fameio/input/scenario/generalproperties.py,sha256=hfcp3fbE7ZtdXo9RrVTiObzHS05jxXf3A5kQP-FSMK8,3824
-fameio/input/scenario/scenario.py,sha256=HOCeYj0i2aoLTpmwoywj0LEnfWjjJN_AHete9ZsbPTw,8422
+fameio/input/scenario/scenario.py,sha256=KtBVQshth7X5nA0SoN7nfbDPLmBU9z5vXQeVIh-tR2c,8498
 fameio/input/scenario/stringset.py,sha256=wDMh0teCX1oiANafrua-_r1DyufL8zfXYQ9e6wlYFdE,2576
 fameio/input/schema/__init__.py,sha256=PAqAvShdyhbxIa95WhJAVsiqeAFXYzb_nJiAHky84cU,401
 fameio/input/schema/agenttype.py,sha256=cnYgAv70ylqnLZJiDar7pqBUGhcr4RqkrC7BZetmgHo,5735
@@ -29,15 +29,16 @@ fameio/input/validator.py,sha256=55dE89u3Y6gYF3ClWXqKdctiVj6CvSU8l6kc1nJ6GEI,241
 fameio/input/writer.py,sha256=s-BarcsB6c8WqKBx3ctIp58EzqZWHceevMId_A-9df0,16635
 fameio/logs.py,sha256=HgdiotKyp9X308RFXhWAlLVzJjcDSBWZzI-vPRoftls,4595
 fameio/output/__init__.py,sha256=euHuzU3Uq4qWHOJvewNxobqYUha5mxidLuGTkus_Q2o,320
-fameio/output/agent_type.py,sha256=V4wsleNQGp6XLMURHLzYvSGy7K0e9_BiC9WVnBlWmzU,7133
+fameio/output/agent_type.py,sha256=fuduSoIk8pw_33ZigMkI3WvC5IQieTDoThEn1C1QLKw,7174
 fameio/output/conversion.py,sha256=Z-x9vLqygFIBIpKGQ-z-qvOWyTobowug1QuI6BhS9dA,4769
-fameio/output/csv_writer.py,sha256=AhUfZSoRemhQ4Zsd8RK3t-LiZrQAaekLkT5PcqSDr_Q,8183
+fameio/output/csv_writer.py,sha256=bzpLc5iNGJlCU4vDFJel7air3E2Hk8jFYBgiXJu0HME,6745
 fameio/output/data_transformer.py,sha256=--sUTADUL66F4zUmw6dOFuBoaJ8gdo_p22HLU8j-ZEQ,5321
 fameio/output/execution_dao.py,sha256=mP1YiTh3_TNgocrJzYqAkdo42oyx7etVTcaQVoOb5QE,7042
-fameio/output/input_dao.py,sha256=fs2SMvI7_aIIwAfMZdyHKGCgumFcFkJE9OGkKHlp4Jk,8530
+fameio/output/files.py,sha256=v01a6KWjYIvT0x9pcDQF4MAwsQrpfcaI4fjjx2OtBTc,2100
+fameio/output/input_dao.py,sha256=HHMJYt0GVjc7GggsvNSxiSTEdm511MEeA9OHQE_xr1A,10781
 fameio/output/metadata/__init__.py,sha256=JbKAcupner2ol7u5p2UyI0x-19OCd_INs24pW_VKmzc,339
 fameio/output/metadata/compiler.py,sha256=r1p_yXqRlS32vo3R0yzdQdBYz5x19WE9I9DKNCRicbY,2958
-fameio/output/metadata/json_writer.py,sha256=i-y_AuPLUiXaVhbZdVBM6gbLzvY8cC7AMdUIdG8Ky_0,1159
+fameio/output/metadata/json_writer.py,sha256=58Uuts78R7thAHkCn3mQvJ4uspbPXt8poGck_FKLr6A,1171
 fameio/output/metadata/locator.py,sha256=_ky_aRdY-ktg7FtTRpPgojsu2VwUcFSx7tSYc7vU87w,9859
 fameio/output/metadata/oeo_template.py,sha256=LfxdnJ1go5OjckfmoeAuZ6ltYzEbH_gHjofOBnqmOQI,4160
 fameio/output/metadata/template_reader.py,sha256=A51XrHkr6ck2qHI3ZXJT0AxxXNl_-3Eyw0ada5ZnZws,2071
@@ -45,23 +46,20 @@ fameio/output/output_dao.py,sha256=eS3BwnK8-3GY2mjh1A2ypdlq1bwBTWSxyWnxtqRSOVA,4
 fameio/output/reader.py,sha256=AgCFDh_vBbLjLxN85OdC_AMOHC3Zst-U69FEa3sdLN4,6603
 fameio/output/yaml_writer.py,sha256=tXNmMHFwpteQwpuREULjNCUQkxJ-OvtKe4Ep_GvGkSg,1131
 fameio/scripts/__init__.py,sha256=8E2JBeaPRM4fmXC3zIugjaUNA1NIBugs5IHc5pZMiMc,1539
-fameio/scripts/__init__.py.license,sha256=2-OqCNxP4504xY2XQqseYypJi1_Qx4xJSzO3t7c3ACM,107
-fameio/scripts/convert_results.py,sha256=AJKn5x8AFMv7VFBhdat9FoJXd3B7rx5neDaJZMcR3S0,9569
-fameio/scripts/convert_results.py.license,sha256=EXKiZn-aoR7nO3auGMNGk9upHbobPLHAIBYUO0S6LUg,107
+fameio/scripts/convert_results.py,sha256=4Dzf-GYCtc8_XuWXG0LuDcog5SkgWItUJ0YZn__4WfY,9472
 fameio/scripts/exception.py,sha256=zaIJ3V-KaAOwggW72DSo-LmyN2jtdTG4R-oYi1liVBc,283
 fameio/scripts/make_config.py,sha256=O6GghQ1M1Y6bxlaS1c9joB066SCaCWvG_V-WTFqFreU,2016
-fameio/scripts/make_config.py.license,sha256=EXKiZn-aoR7nO3auGMNGk9upHbobPLHAIBYUO0S6LUg,107
-fameio/scripts/reformat.py,sha256=jYJsl0UkXtZyn2GyA-QVAARilkHa_ZBWa5CGNIGNDuo,2850
-fameio/scripts/reformat.py.license,sha256=EXKiZn-aoR7nO3auGMNGk9upHbobPLHAIBYUO0S6LUg,107
-fameio/series.py,sha256=KNDKe9CxScYSWacQKJGjwoBEK2I8mezYDAQJfmkU-f8,13987
+fameio/scripts/reformat.py,sha256=8E-zoUiQU_e8RI0a_h06QBt9NkrJwLjc4Mq824kFSTs,3627
+fameio/scripts/REUSE.toml,sha256=6UE87HbRv_xOtHCQULBwsFIhpgPBmDJdrErq92wt22U,160
+fameio/series.py,sha256=tiSqIOOnDtwej0YJxmucXHBdJztlVGFEfv0L9lDBxBw,14073
 fameio/time.py,sha256=jz-5ZXkIhrjcNuF0nNrQTShkyQFoeiyVOu5MEe7MPps,10253
 fameio/tools.py,sha256=A3UtAIb-gH6tCcxuTzoNYrj4COGXISxoU9Tn9M_fmSM,2544
-fameio-3.5.0.dist-info/entry_points.txt,sha256=IUbTceB_CLFOHulubEf9jgiCFsV2TchlzCssmjbiOKI,176
-fameio-3.5.0.dist-info/LICENSE.txt,sha256=eGHBZnhr9CWjE95SWjRfmhtK1lvVn5X4Fpf3KrrAZDg,10391
-fameio-3.5.0.dist-info/LICENSES/Apache-2.0.txt,sha256=eGHBZnhr9CWjE95SWjRfmhtK1lvVn5X4Fpf3KrrAZDg,10391
-fameio-3.5.0.dist-info/LICENSES/CC-BY-4.0.txt,sha256=y9WvMYKGt0ZW8UXf9QkZB8wj1tjJrQngKR7CSXeSukE,19051
-fameio-3.5.0.dist-info/LICENSES/CC-BY-ND-4.0.txt,sha256=i8xEGbjrLjDix0UDvo7U7-Mgb-riQ2jxX2Jozaz4U9k,18829
-fameio-3.5.0.dist-info/LICENSES/CC0-1.0.txt,sha256=9Ofzc7m5lpUDN-jUGkopOcLZC3cl6brz1QhKInF60yg,7169
-fameio-3.5.0.dist-info/METADATA,sha256=Ui_POdIBbt6Cv2KpCPKL7Y29HUsC6ri-GmL7Ob9zM8U,4796
-fameio-3.5.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-fameio-3.5.0.dist-info/RECORD,,
+fameio-3.5.1.dist-info/entry_points.txt,sha256=IUbTceB_CLFOHulubEf9jgiCFsV2TchlzCssmjbiOKI,176
+fameio-3.5.1.dist-info/LICENSE.txt,sha256=eGHBZnhr9CWjE95SWjRfmhtK1lvVn5X4Fpf3KrrAZDg,10391
+fameio-3.5.1.dist-info/LICENSES/Apache-2.0.txt,sha256=eGHBZnhr9CWjE95SWjRfmhtK1lvVn5X4Fpf3KrrAZDg,10391
+fameio-3.5.1.dist-info/LICENSES/CC-BY-4.0.txt,sha256=y9WvMYKGt0ZW8UXf9QkZB8wj1tjJrQngKR7CSXeSukE,19051
+fameio-3.5.1.dist-info/LICENSES/CC-BY-ND-4.0.txt,sha256=i8xEGbjrLjDix0UDvo7U7-Mgb-riQ2jxX2Jozaz4U9k,18829
+fameio-3.5.1.dist-info/LICENSES/CC0-1.0.txt,sha256=9Ofzc7m5lpUDN-jUGkopOcLZC3cl6brz1QhKInF60yg,7169
+fameio-3.5.1.dist-info/METADATA,sha256=BAtKp3BRkT3UnujpZj5hXszmpzWOTBwAUzOlM4OMA48,4796
+fameio-3.5.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+fameio-3.5.1.dist-info/RECORD,,

fameio/scripts/__init__.py.license

@@ -1,3 +0,0 @@
-SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
-
-SPDX-License-Identifier: Apache-2.0

fameio/scripts/convert_results.py.license

@@ -1,3 +0,0 @@
-SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
-
-SPDX-License-Identifier: Apache-2.0

fameio/scripts/make_config.py.license

@@ -1,3 +0,0 @@
-SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
-
-SPDX-License-Identifier: Apache-2.0

fameio/scripts/reformat.py.license

@@ -1,3 +0,0 @@
-SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
-
-SPDX-License-Identifier: Apache-2.0