fameio 3.5.0__tar.gz → 3.5.2__tar.gz

{fameio-3.5.0 → fameio-3.5.2}/CHANGELOG.md

@@ -1,7 +1,21 @@
 <!-- SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 
 SPDX-License-Identifier: Apache-2.0 -->
-##  [3.5.0](https://gitlab.com/fame-framework/fame-io/-/tags/v3.5.0) - 2025-07-02
+# Changelog
+## [3.5.2](https://gitlab.com/fame-framework/fame-io/-/tags/v3.5.2) - 2025-10-14
+### Fixed
+- Fix conversion of time stamps on input recovery based on user specifications #274 (@dlr_fn)
+
+## [3.5.1](https://gitlab.com/fame-framework/fame-io/-/tags/v3.5.1) - 2025-07-25
+### Fixed
+- Fix crash on result conversion if agent list is provided #266 (@dlr-cjs, @dlr_jk)
+- Fix missing recovery of scenario StringSets #264 (@dlr-cjs)
+- Fix missing recovery of scenario metadata #263 (@dlr-cjs)
+- Fix missing recovery of agent attribute metadata #265 (@dlr-cjs)
+- Fix unexpected abort of file conversion if any file cannot be converted #268 (@dlr-cjs)
+- Correct location of `metadata.json` if output folder is unspecified #262 (@dlr-cjs)
+
+## [3.5.0](https://gitlab.com/fame-framework/fame-io/-/tags/v3.5.0) - 2025-07-02
 ### Changed
 - Move most documentation from README to docs folder #200 (@dlr-cjs, @dlr_fn, @LeonardWilleke)
 - Update minimum fameprotobuf dependency to v2.1.0 #256 (@dlr-cjs)
@@ -14,7 +28,7 @@ SPDX-License-Identifier: Apache-2.0 -->
 - Save scenario attribute metadata to protobuf #255 (@dlr-cjs)
 - Create documentation with sphinx #47 (@dlr-cjs, @dlr_fn)
 
-##  [3.4.0](https://gitlab.com/fame-framework/fame-io/-/tags/v3.4.0) - 2025-05-27
+## [3.4.0](https://gitlab.com/fame-framework/fame-io/-/tags/v3.4.0) - 2025-05-27
 ### Changed
 - Allow nesting of sender or receiver lists in contracts !228 (@dlr-cjs)
 

{fameio-3.5.0 → fameio-3.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fameio
-Version: 3.5.0
+Version: 3.5.2
 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 → fameio-3.5.2}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "fameio"
-version = "3.5.0"
+version = "3.5.2"
 description = "Tools for input preparation and output digestion of FAME models"
 license = "Apache-2.0"
 readme = "README.md"

{fameio-3.5.0 → fameio-3.5.2}/src/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-3.5.0 → fameio-3.5.2}/src/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-3.5.0 → fameio-3.5.2}/src/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-3.5.0 → fameio-3.5.2}/src/fameio/output/conversion.py

@@ -12,7 +12,10 @@ import pandas as pd
 from fameio.cli.options import TimeOptions
 from fameio.logs import log_error, log
 from fameio.output import OutputError
-from fameio.time import FameTime, ConversionError as TimeConversionError
+from fameio.series import TimeSeriesManager
+from fameio.time import FameTime, ConversionError as TimeConversionError, DATE_FORMAT as DATETIME_FORMAT_FAME
+
+DATETIME_FORMAT_UTC = "%Y-%m-%d %H:%M:%S"
 
 _ERR_UNIMPLEMENTED = "Time conversion mode '{}' not implemented."
 _ERR_TIME_CONVERSION = "Conversion of timestamps failed."
@@ -86,9 +89,9 @@ def apply_time_option(data: dict[str | None, pd.DataFrame], mode: TimeOptions) -
         if mode == TimeOptions.INT:
             log().debug("No time conversion...")
         elif mode == TimeOptions.UTC:
-            _convert_time_index(data, "%Y-%m-%d %H:%M:%S")
+            _convert_time_index(data, DATETIME_FORMAT_UTC)
         elif mode == TimeOptions.FAME:
-            _convert_time_index(data, "%Y-%m-%d_%H:%M:%S")
+            _convert_time_index(data, DATETIME_FORMAT_FAME)
         else:
             raise log_error(ConversionError(_ERR_UNIMPLEMENTED.format(mode)))
     except TimeConversionError as e:
@@ -111,5 +114,7 @@ def _convert_time_index(data: dict[str | None, pd.DataFrame], datetime_format: s
     for _, df in data.items():
         index_columns = df.index.names
         df.reset_index(inplace=True)
-        df["TimeStep"] = df["TimeStep"].apply(lambda t: FameTime.convert_fame_time_step_to_datetime(t, datetime_format))
+        df[TimeSeriesManager.KEY_ROW_TIME] = df[TimeSeriesManager.KEY_ROW_TIME].apply(
+            lambda t: FameTime.convert_fame_time_step_to_datetime(t, datetime_format)
+        )
         df.set_index(keys=index_columns, inplace=True)

{fameio-3.5.0 → fameio-3.5.2}/src/fameio/output/csv_writer.py

@@ -6,11 +6,14 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Literal
 
 import pandas as pd
 
-from fameio.logs import log, log_error
+from fameio.cli.options import TimeOptions
+from fameio.logs import log_error
 from fameio.output import OutputError
+from fameio.output.conversion import apply_time_option
 from fameio.output.data_transformer import INDEX
 from fameio.series import TimeSeriesManager
 from fameio.tools import ensure_path_exists
@@ -23,49 +26,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).
@@ -87,11 +62,14 @@ class CsvWriter:
                 identifier = self._get_identifier(agent_name, column_name)
                 self._write_data_frame(column_data, identifier)
 
-    def write_all_time_series_to_disk(self, timeseries_manager: TimeSeriesManager) -> None:
+    def write_all_time_series_to_disk(
+        self, timeseries_manager: TimeSeriesManager, time_mode: TimeOptions | None = None
+    ) -> None:
         """Writes time_series of given `timeseries_manager` to disk.
 
         Args:
             timeseries_manager: to provide the time series that are to be written
+            time_mode: mode of representing time in series that are to be written
 
         Raises:
             CsvWriterError: if data could not be written to disk, logged on level "ERROR"
@@ -100,6 +78,8 @@ class CsvWriter:
             if data is not None:
                 target_path = Path(self._output_folder, name)
                 ensure_path_exists(target_path.parent)
+                if time_mode:
+                    apply_time_option(data={name: data}, mode=time_mode)
                 self.write_single_time_series_to_disk(data, target_path)
 
     @staticmethod
@@ -113,10 +93,10 @@ class CsvWriter:
         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")
+        CsvWriter._dataframe_to_csv(data, file, header=False, index=True, mode="w")
 
     @staticmethod
-    def _dataframe_to_csv(data: pd.DataFrame, file: Path, header: bool, index: bool, mode: str) -> None:
+    def _dataframe_to_csv(data: pd.DataFrame, file: Path, header: bool, index: bool, mode: Literal["a", "w"]) -> None:
         """Write given data to specified CSV file in UTF8 encoding with specified parameters using semicolon separators.
 
         Args:
@@ -160,7 +140,7 @@ class CsvWriter:
         """
         if self._has_file(identifier):
             outfile_name = self._get_outfile_name(identifier)
-            mode = "a"
+            mode: Literal["a", "w"] = "a"
             header = False
         else:
             outfile_name = self._create_outfile_name(identifier)

fameio-3.5.2/src/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-3.5.0 → fameio-3.5.2}/src/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-3.5.0 → fameio-3.5.2}/src/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-3.5.2/src/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-3.5.0 → fameio-3.5.2}/src/fameio/scripts/convert_results.py

@@ -3,13 +3,13 @@ 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
 
 from fameio.cli import update_default_config
 from fameio.cli.convert_results import handle_args, CLI_DEFAULTS as DEFAULT_CONFIG
-from fameio.cli.options import Options
+from fameio.cli.options import Options, TimeOptions
 from fameio.input import InputError
 from fameio.logs import fameio_logger, log, log_error, log_critical
 from fameio.output import OutputError
@@ -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(), config[Options.TIME])
     if config[Options.MEMORY_SAVING]:
         _memory_saving_apply_conversions(config, output_writer)
 
@@ -100,17 +109,23 @@ 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, time_mode: TimeOptions) -> 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
+        time_mode: mode of representing time in recovered input time series
 
     Raises:
         OutputError: if inputs could not be recovered or saved to files, logged with level "ERROR"
@@ -120,12 +135,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.write_all_time_series_to_disk(timeseries)
-    data_to_yaml_file(scenario.to_dict(), Path(base_path, "./recovered/scenario.yaml"))
+
+    series_writer = CsvWriter(output_folder=Path(output_path, RECOVERED_INPUT_PATH), single_export=False)
+    series_writer.write_all_time_series_to_disk(timeseries, time_mode)
+    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 +162,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-3.5.0 → fameio-3.5.2}/src/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-3.5.0 → fameio-3.5.2}/src/fameio/series.py

@@ -8,11 +8,12 @@ import math
 import os
 from enum import Enum, auto
 from pathlib import Path
-from typing import Any
+from typing import Any, Final
 
 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
@@ -40,10 +41,11 @@ class Entry(Enum):
 class TimeSeriesManager:
     """Manages matching of timeseries data from files and values to unique ids and vice versa."""
 
+    KEY_ROW_TIME: Final[str] = "TimeStep"
+    KEY_ROW_VALUE: Final[str] = "Value"
+
     _TIMESERIES_RECONSTRUCTION_PATH = "./timeseries/"
     _CONSTANT_IDENTIFIER = "Constant value: {}"
-    _KEY_ROW_TIME = "timeStep"
-    _KEY_ROW_VALUE = "value"
 
     _ERR_FILE_NOT_FOUND = "Cannot find Timeseries file '{}'."
     _ERR_NUMERIC_STRING = " Remove quotes to use a constant numeric value instead of a timeseries file."
@@ -141,7 +143,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
@@ -273,7 +275,7 @@ class TimeSeriesManager:
         """Reconstructs and stores time series from given list of `timeseries_dao`."""
         for one_series in timeseries:
             self._id_count += 1
-            reconstructed = {Entry.ID: one_series.series_id}
+            reconstructed: dict[Entry, int | float | None | str | pd.DataFrame] = {Entry.ID: one_series.series_id}
             if len(one_series.values) == 1 or (
                 len(one_series.values) == 2 and one_series.values[0] == one_series.values[1]
             ):
@@ -282,7 +284,8 @@ class TimeSeriesManager:
             else:
                 reconstructed[Entry.NAME] = self._get_cleaned_file_name(one_series.series_name)
                 reconstructed[Entry.DATA] = pd.DataFrame(
-                    {self._KEY_ROW_TIME: list(one_series.time_steps), self._KEY_ROW_VALUE: list(one_series.values)}
+                    data={self.KEY_ROW_VALUE: list(one_series.values)},
+                    index=pd.Index(data=list(one_series.time_steps), name=self.KEY_ROW_TIME),
                 )
             self._series_by_id[one_series.series_id] = reconstructed
 

fameio-3.5.0/src/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-3.5.0/src/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-3.5.0/src/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-3.5.0/src/fameio/scripts/reformat.py.license

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