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

fameio/output/output_dao.py

@@ -14,7 +14,7 @@ from fameio.output.data_transformer import DataTransformer
 
 
 class OutputDAO:
-    """Grants convenient access to content of Output protobuf messages for given DataStorages"""
+    """Grants convenient access to content of Output protobuf messages for given DataStorages."""
 
     def __init__(self, data_storages: list[DataStorage], agent_type_log: AgentTypeLog) -> None:
         """
@@ -34,21 +34,21 @@ class OutputDAO:
 
     @staticmethod
     def _extract_output_from_data_storages(data_storages: list[DataStorage]) -> list[Output]:
-        """Returns list of Outputs extracted from given `data_storages`"""
+        """Returns list of Outputs extracted from given `data_storages`."""
         if data_storages is None:
             data_storages = []
         return [data_storage.output for data_storage in data_storages if data_storage.HasField("output")]
 
     @staticmethod
     def _extract_new_agent_types(outputs: list[Output]) -> dict[str, Output.AgentType]:
-        """Returns dict of agent names mapped to its type defined in given `outputs`"""
+        """Returns dict of agent names mapped to its type defined in given `outputs`."""
         list_of_agent_type_lists = [output.agent_types for output in outputs if len(output.agent_types) > 0]
         list_of_agent_types = [item for sublist in list_of_agent_type_lists for item in sublist]
         return {item.class_name: item for item in list_of_agent_types}
 
     @staticmethod
     def _extract_series(outputs: list[Output]) -> dict[str, list[Output.Series]]:
-        """Returns series data from associated `outputs` mapped to the className of its agent"""
+        """Returns series data from associated `outputs` mapped to the className of its agent."""
         list_of_series_lists = [output.series for output in outputs if len(output.series) > 0]
         list_of_series = [series for sublist in list_of_series_lists for series in sublist]
 
@@ -60,7 +60,7 @@ class OutputDAO:
         return series_per_class_name
 
     def get_sorted_agents_to_extract(self) -> Iterable[str]:
-        """Returns iterator of requested and available agent names in ascending order by count of series"""
+        """Returns iterator of requested and available agent names in ascending order by count of series."""
         all_series = self._get_agent_names_by_series_count_ascending()
         filtered_series = [agent_name for agent_name in all_series if self._agent_type_log.is_requested(agent_name)]
         return iter(filtered_series)
@@ -72,8 +72,8 @@ class OutputDAO:
         return [agent_name for agent_name, _ in sorted_dict]
 
     def get_agent_data(self, agent_name: str, data_transformer: DataTransformer) -> dict[str | None, pd.DataFrame]:
-        """
-        Returns DataFrame(s) containing all data of given `agent` - data is removed after the first call
+        """Returns DataFrame(s) containing all data of given `agent` - data is removed after the first call.
+
         Depending on the chosen ResolveOption the dict contains one DataFrame for the simple (and merged columns),
         or, in `SPLIT` mode, additional DataFrames mapped to each complex column's name.
 

fameio/output/reader.py

@@ -16,11 +16,11 @@ from fameio.output import OutputError
 
 
 class ProtobufReaderError(OutputError):
-    """Indicates an error while reading a protobuf file"""
+    """Indicates an error while reading a protobuf file."""
 
 
 class Reader(ABC):
-    """Abstract base class for protobuf file readers"""
+    """Abstract base class for protobuf file readers."""
 
     _ERR_FILE_READ = "Could not read file content."
     _ERR_HEADER_UNRECOGNISED = ""
@@ -55,8 +55,7 @@ class Reader(ABC):
 
     @abstractmethod
     def read(self) -> list[DataStorage]:
-        """
-        Reads associated filestream and returns one or multiple DataStorage(s) or empty list
+        """Reads associated filestream and returns one or multiple DataStorage(s) or empty list.
 
         Returns:
             one or multiple DataStorage protobuf object(s) read from file
@@ -67,8 +66,7 @@ class Reader(ABC):
 
     @staticmethod
     def get_reader(file: IO, read_single: bool = False) -> Reader:
-        """
-        Returns reader matching the given file header
+        """Returns reader matching the given file header.
 
         Args:
             file: to be read by the returned Reader
@@ -99,7 +97,7 @@ class Reader(ABC):
 
     @final
     def _read_message_length(self) -> int:
-        """Returns length of next DataStorage message in file"""
+        """Returns length of next DataStorage message in file."""
         message_length_byte = self._file.read(self.BYTES_DEFINING_MESSAGE_LENGTH)
         if not message_length_byte:
             log().debug(self._DEBUG_FILE_END_REACHED)
@@ -110,8 +108,8 @@ class Reader(ABC):
 
     @final
     def _read_data_storage_message(self, message_length: int | None = None) -> DataStorage:
-        """
-        Returns given `data_storage` read from current file position and following `message_length` bytes.
+        """Returns data storage read from current file position and following `message_length` bytes.
+
         If `message_length` is omitted, the rest of the file is read. If no message is found, None is returned.
 
         Args:
@@ -157,7 +155,7 @@ class Reader(ABC):
 
 
 class ReaderV2(Reader):
-    """Reader class for `fame-core>=2.0` output with header of version v002"""
+    """Reader class for `fame-core>=2.0` output with header of version v002."""
 
     def read(self) -> list[DataStorage]:
         messages = []

fameio/output/yaml_writer.py

@@ -14,12 +14,11 @@ _INFO_DESTINATION = "Saving scenario to file at {}"
 
 
 class YamlWriterError(OutputError):
-    """An error occurred during writing a YAML file"""
+    """An error occurred during writing a YAML file."""
 
 
 def data_to_yaml_file(data: dict, file_path: Path) -> None:
-    """
-    Save the given data to a YAML file at given path
+    """Save the given data to a YAML file at given path.
 
     Args:
         data: to be saved to yaml file

fameio/scripts/__init__.py

@@ -5,23 +5,34 @@ from fameio.scripts.convert_results import DEFAULT_CONFIG as DEFAULT_CONVERT_CON
 from fameio.scripts.convert_results import run as convert_results
 from fameio.scripts.exception import ScriptError
 from fameio.scripts.make_config import run as make_config
+from fameio.scripts.reformat import run as reformat
 from fameio.cli.convert_results import handle_args as handle_convert_results_args
 from fameio.cli.make_config import handle_args as handle_make_config_args
+from fameio.cli.reformat import handle_args as handle_reformat_args
 
 
 # noinspection PyPep8Naming
 def makeFameRunConfig():
-    run_config = handle_make_config_args(sys.argv[1:])
+    cli_config = handle_make_config_args(sys.argv[1:])
     try:
-        make_config(run_config)
+        make_config(cli_config)
     except ScriptError as e:
         raise SystemExit(1) from e
 
 
 # noinspection PyPep8Naming
 def convertFameResults():
-    run_config = handle_convert_results_args(sys.argv[1:], DEFAULT_CONVERT_CONFIG)
+    cli_config = handle_convert_results_args(sys.argv[1:], DEFAULT_CONVERT_CONFIG)
     try:
-        convert_results(run_config)
+        convert_results(cli_config)
+    except ScriptError as e:
+        raise SystemExit(1) from e
+
+
+# noinspection PyPep8Naming
+def reformatTimeSeries():
+    cli_config = handle_reformat_args(sys.argv[1:])
+    try:
+        reformat(cli_config)
     except ScriptError as e:
         raise SystemExit(1) from e

fameio/scripts/convert_results.py

@@ -17,6 +17,7 @@ from fameio.output.agent_type import AgentTypeLog
 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.input_dao import InputDao
 from fameio.output.output_dao import OutputDAO
 from fameio.output.reader import Reader
@@ -26,7 +27,7 @@ from fameio.scripts.exception import ScriptError
 _ERR_OUT_OF_MEMORY = "Out of memory. Retry result conversion using `-m` or `--memory-saving` option."
 _ERR_MEMORY_SEVERE = "Out of memory despite memory-saving mode. Reduce output interval in `FAME-Core` and rerun model."
 _ERR_FILE_OPEN_FAIL = "Could not open file: '{}'"
-_ERR_RECOVER_INPUT = "Could not recover inputs due to an incompatibility with this version of fameio."
+_ERR_RECOVER_INPUT = "Input recovery failed: File was created with `fameio=={}`. Use that version to recover inputs."
 _ERR_FAIL = "Results conversion script failed."
 
 _WARN_OUTPUT_SUPPRESSED = "All output data suppressed by agent filter, but there is data available for agent types: {}"
@@ -35,8 +36,7 @@ _INFO_MEMORY_SAVING = "Memory saving mode enabled: Disable on conversion of smal
 
 
 def _read_and_extract_data(config: dict[Options, Any]) -> None:
-    """
-    Read protobuf file, extracts, converts, and saves the converted data; Returns false if no result data was found
+    """Read protobuf file, extracts, converts, and saves the converted data.
 
     Args:
         config: script configuration options
@@ -54,8 +54,7 @@ def _read_and_extract_data(config: dict[Options, Any]) -> None:
 
 
 def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO, file_path: Path) -> None:
-    """
-    Extracts data from provided input file stream, converts it, and writes the result to output files
+    """Extracts data from provided input file stream, converts it, and writes the result to output files.
 
     Args:
         config: script configuration options
@@ -71,7 +70,9 @@ def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO,
     data_transformer = DataTransformer.build(config[Options.RESOLVE_COMPLEX_FIELD])
     reader = Reader.get_reader(file=file_stream, read_single=config[Options.MEMORY_SAVING])
     input_dao = InputDao()
+    execution_dao = ExecutionDao()
     while data_storages := reader.read():
+        execution_dao.store_execution_metadata(data_storages)
         if config[Options.INPUT_RECOVERY]:
             input_dao.store_inputs(data_storages)
         output = OutputDAO(data_storages, agent_type_log)
@@ -85,7 +86,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)
+        _recover_inputs(config, input_dao, execution_dao.get_fameio_version())
     if config[Options.MEMORY_SAVING]:
         _memory_saving_apply_conversions(config, output_writer)
 
@@ -97,13 +98,13 @@ def _extract_and_convert_data(config: dict[Options, Any], file_stream: BinaryIO,
     log().info("Data conversion completed.")
 
 
-def _recover_inputs(config: dict[Options, Any], input_dao: InputDao) -> None:
-    """
-    Reads scenario configuration from provided input_dao
+def _recover_inputs(config: dict[Options, Any], input_dao: InputDao, fameio_version: str) -> None:
+    """Reads scenario configuration from provided `input_dao`.
 
     Args:
         config: script configuration options
         input_dao: to recover the input data from
+        fameio_version: version of fameio that was used to create the input data
 
     Raises:
         OutputError: if inputs could not be recovered or saved to files, logged with level "ERROR"
@@ -112,18 +113,19 @@ def _recover_inputs(config: dict[Options, Any], input_dao: InputDao) -> None:
     try:
         timeseries, scenario = input_dao.recover_inputs()
     except InputError as ex:
-        raise log_error(OutputError(_ERR_RECOVER_INPUT)) from 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_time_series_to_disk(timeseries)
+    series_writer.write_all_time_series_to_disk(timeseries)
     data_to_yaml_file(scenario.to_dict(), Path(base_path, "./recovered/scenario.yaml"))
 
 
 def _memory_saving_apply_conversions(config: dict[Options, Any], output_writer: CsvWriter) -> None:
-    """
-    Rewrite result files in memory saving mode: apply time-merging and time conversion options on a per-file basis
+    """Rewrite result files: applies time-merging and time conversion options on a per-file basis.
+
+    This is only required in memory saving mode.
 
     Args:
         config: script configuration options
@@ -142,8 +144,7 @@ def _memory_saving_apply_conversions(config: dict[Options, Any], output_writer:
 
 
 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
@@ -167,8 +168,8 @@ def run(config: dict[Options, Any] | None = None) -> None:
 
 
 if __name__ == "__main__":
-    run_config = handle_args(sys.argv[1:])
+    cli_config = handle_args(sys.argv[1:])
     try:
-        run(run_config)
+        run(cli_config)
     except ScriptError as e:
         raise SystemExit(1) from e

fameio/scripts/exception.py

@@ -4,4 +4,4 @@
 
 
 class ScriptError(Exception):
-    """Any kind of expected error that occurred during execution of FAME-Io scripts"""
+    """Any kind of expected error that occurred during execution of FAME-Io scripts."""

fameio/scripts/make_config.py

@@ -20,8 +20,7 @@ _ERR_FAIL: str = "Creation of run configuration file failed."
 
 
 def run(config: dict[Options, Any] | None = None) -> None:
-    """
-    Executes the main workflow of building a FAME configuration file
+    """Executes the main workflow of building a FAME configuration file.
 
     Args:
         config: configuration options
@@ -49,8 +48,8 @@ def run(config: dict[Options, Any] | None = None) -> None:
 
 
 if __name__ == "__main__":
-    run_config = handle_args(sys.argv[1:])
+    cli_config = handle_args(sys.argv[1:])
     try:
-        run(run_config)
+        run(cli_config)
     except ScriptError as e:
         raise SystemExit(1) from e

fameio/scripts/reformat.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from fameio.cli import update_default_config
+from fameio.cli.options import Options
+from fameio.cli.reformat import handle_args, CLI_DEFAULTS as DEFAULT_CONFIG
+from fameio.logs import fameio_logger, log_error, log_and_print
+from fameio.output.csv_writer import CsvWriter, CsvWriterError
+from fameio.scripts.exception import ScriptError
+from fameio.series import TimeSeriesManager, TimeSeriesError
+from fameio.tools import get_csv_files_with_pattern, extend_file_name
+
+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: '{}'"
+
+
+def reformat_file(file: Path, replace: bool) -> None:
+    """Transforms content of specified CSV file to FAME format.
+
+    Args:
+        file: whose content is to be reformatted
+        replace: if true, original file will be replaced; otherwise, a new file will be created instead
+
+    Raises:
+        ScriptError: if file could not be read, file reformatting failed, or result file could not be written;
+            logged with level "ERROR"
+    """
+    try:
+        data = TimeSeriesManager.read_timeseries_file(file)
+        data = TimeSeriesManager.check_and_convert_series(data, str(file), warn=False)
+        target_path = file if replace else extend_file_name(file, FILE_NAME_APPENDIX)
+        CsvWriter.write_single_time_series_to_disk(data, target_path)
+    except (TimeSeriesError, CsvWriterError) as ex:
+        raise log_error(ScriptError(_ERR_FILE_CONVERSION.format(file))) from ex
+
+
+def run(config: dict[Options, Any] | None = None) -> None:
+    """Executes the workflow of transforming time series file(s).
+
+    Args:
+        config: configuration options
+
+    Raises:
+        ScriptError: if no file could be found, or if any file could not be transformed, logged with level "ERROR"
+    """
+    config = update_default_config(config, DEFAULT_CONFIG)
+    fameio_logger(log_level_name=config[Options.LOG_LEVEL], file_name=config[Options.LOG_FILE])
+    try:
+        files = get_csv_files_with_pattern(Path("."), config[Options.FILE_PATTERN])
+    except ValueError as ex:
+        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])))
+    for file in files:
+        log_and_print(f"Reformatting file: {file}")
+        reformat_file(file, config[Options.REPLACE])
+
+
+if __name__ == "__main__":
+    cli_config = handle_args(sys.argv[1:])
+    try:
+        run(cli_config)
+    except ScriptError as e:
+        raise SystemExit(1) from e

fameio/scripts/reformat.py.license

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

fameio/series.py

@@ -18,9 +18,9 @@ from fameio.input.resolver import PathResolver
 from fameio.logs import log, log_error
 from fameio.output import OutputError
 from fameio.time import ConversionError, FameTime
-from fameio.tools import clean_up_file_name
+from fameio.tools import clean_up_file_name, CSV_FILE_SUFFIX
+
 
-CSV_FILE_SUFFIX = ".csv"
 FILE_LENGTH_WARN_LIMIT = int(50e3)
 
 
@@ -35,7 +35,7 @@ class Entry(Enum):
 
 
 class TimeSeriesManager:
-    """Manages matching of files to time series ids and their protobuf representation"""
+    """Manages matching of files to time series ids and their protobuf representation."""
 
     _TIMESERIES_RECONSTRUCTION_PATH = "./timeseries/"
     _CONSTANT_IDENTIFIER = "Constant value: {}"
@@ -44,14 +44,14 @@ class TimeSeriesManager:
 
     _ERR_FILE_NOT_FOUND = "Cannot find Timeseries file '{}'."
     _ERR_NUMERIC_STRING = " Remove quotes to use a constant numeric value instead of a timeseries file."
-    _ERR_CORRUPT_TIME_SERIES_KEY = "TimeSeries file '{}' corrupt: At least one entry in first column isn't a timestamp."
-    _ERR_CORRUPT_TIME_SERIES_VALUE = "TimeSeries file '{}' corrupt: At least one entry in second column isn't numeric."
+    _ERR_CORRUPT_KEYS = "TimeSeries file '{}' corrupt: At least one entry in first column isn't a timestamp."
+    _ERR_CORRUPT_VALUES = "TimeSeries file '{}' corrupt: At least one entry in second column isn't numeric."
     _ERR_NON_NUMERIC = "Values in TimeSeries must be numeric but was: '{}'"
     _ERR_NAN_VALUE = "Values in TimeSeries must not be missing or NaN."
     _ERR_UNREGISTERED_SERIES = "No timeseries registered with identifier '{}' - was the Scenario validated?"
     _ERR_UNREGISTERED_SERIES_RE = "No timeseries registered with identifier '{}' - were the timeseries reconstructed?"
     _WARN_NO_DATA = "No timeseries stored in timeseries manager. Double check if you expected timeseries."
-    _WARN_DATA_IGNORED = "Timeseries contains additional columns with data which will be ignored."
+    _WARN_DATA_IGNORED = "Timeseries '{}' contains additional columns with data which will be ignored."
     _WARN_LARGE_CONVERSION = (
         "Timeseries file '{}' is large and needs conversion of time stamps. If performance "
         "issues occur and the file is reused, convert the time stamp column once with "
@@ -64,8 +64,7 @@ class TimeSeriesManager:
         self._series_by_id: dict[str | int | float, dict[Entry, Any]] = {}
 
     def register_and_validate(self, identifier: str | int | float) -> None:
-        """
-        Registers given timeseries `identifier` and validates associated timeseries
+        """Registers given timeseries `identifier` and validates associated timeseries.
 
         Args:
             identifier: to be registered - either a single numeric value or a string pointing to a timeseries file
@@ -78,12 +77,11 @@ class TimeSeriesManager:
             self._register_time_series(identifier)
 
     def _time_series_is_registered(self, identifier: str | int | float) -> bool:
-        """Returns True if the value was already registered"""
+        """Returns True if the value was already registered."""
         return identifier in self._series_by_id
 
     def _register_time_series(self, identifier: str | int | float) -> None:
-        """
-        Assigns an id to the given `identifier` and loads the time series into a dataframe
+        """Assigns an id to the given `identifier` and loads the time series into a dataframe.
 
         Args:
             identifier: to be registered - either a single numeric value or a string pointing to a timeseries file
@@ -97,8 +95,7 @@ class TimeSeriesManager:
         self._series_by_id[identifier] = {Entry.ID: self._id_count, Entry.NAME: name, Entry.DATA: series}
 
     def _get_name_and_dataframe(self, identifier: str | int | float) -> tuple[str, pd.DataFrame]:
-        """
-        Returns name and DataFrame containing the series obtained from the given `identifier`
+        """Returns name and DataFrame containing the series obtained from the given `identifier`.
 
         Args:
             identifier: to be registered - either a single numeric value or a string pointing to a timeseries file
@@ -113,56 +110,92 @@ class TimeSeriesManager:
         if isinstance(identifier, str):
             series_path = self._path_resolver.resolve_series_file_path(Path(identifier).as_posix())
             if series_path and os.path.exists(series_path):
-                try:
-                    data = pd.read_csv(series_path, sep=";", header=None, comment="#")
-                except OSError as e:
-                    raise log_error(TimeSeriesError(e)) from e
-                try:
-                    return identifier, self._check_and_convert_series(data, identifier)
-                except TypeError as e:
-                    raise log_error(TimeSeriesError(self._ERR_CORRUPT_TIME_SERIES_VALUE.format(identifier), e)) from e
-                except ConversionError as e:
-                    raise log_error(TimeSeriesError(self._ERR_CORRUPT_TIME_SERIES_KEY.format(identifier), e)) from e
-            else:
-                message = self._ERR_FILE_NOT_FOUND.format(identifier)
-                if self._is_number_string(identifier):
-                    message += self._ERR_NUMERIC_STRING
-                raise log_error(TimeSeriesError(message))
-        else:
-            return self._create_timeseries_from_value(identifier)
+                data = self.read_timeseries_file(series_path)
+                return identifier, self.check_and_convert_series(data, identifier)
+            message = self._ERR_FILE_NOT_FOUND.format(identifier)
+            if self._is_number_string(identifier):
+                message += self._ERR_NUMERIC_STRING
+            raise log_error(TimeSeriesError(message))
+        return self._create_timeseries_from_value(identifier)
+
+    @staticmethod
+    def read_timeseries_file(file: Path | str) -> pd.DataFrame:
+        """Loads a timeseries from file.
 
-    def _check_and_convert_series(self, data: pd.DataFrame, identifier: str) -> pd.DataFrame:
+        Args:
+            file: to be read
+
+        Returns:
+            data frame obtained from file
+
+        Raises:
+            TimeSeriesError: if file could not be read, logged with level "ERROR"
         """
-        Ensures validity of time series and convert to required format for writing to disk
+        try:
+            return pd.read_csv(file, sep=";", header=None, comment="#")
+        except OSError as e:
+            raise log_error(TimeSeriesError(e)) from e
+
+    @staticmethod
+    def check_and_convert_series(data: pd.DataFrame, file_name: str, warn: bool = True) -> pd.DataFrame:
+        """Ensures validity of time series and convert to required format for writing to disk.
 
         Args:
             data: dataframe to be converted to expected format
+            file_name: used in warnings and errors
+            warn: if True, a warning is raised if large files require conversion (default: True)
 
         Returns:
             2-column dataframe, first column: integers, second column: floats (no NaN)
 
+        Raises:
+            TimeSeriesError: if the data do not correspond to a valid time series, logged with level "ERROR"
+        """
+        try:
+            converted, large_conversion = TimeSeriesManager._check_and_convert_series(data, file_name)
+            if large_conversion and warn:
+                log().warning(TimeSeriesManager._WARN_LARGE_CONVERSION.format(file_name))
+            return converted
+        except TypeError as e:
+            raise log_error(TimeSeriesError(TimeSeriesManager._ERR_CORRUPT_VALUES.format(file_name), e)) from e
+        except ConversionError as e:
+            raise log_error(TimeSeriesError(TimeSeriesManager._ERR_CORRUPT_KEYS.format(file_name), e)) from e
+
+    @staticmethod
+    def _check_and_convert_series(data: pd.DataFrame, file_name: str) -> tuple[pd.DataFrame, bool]:
+        """Ensures validity of time series and convert to required format for writing to disk.
+
+        Args:
+            data: dataframe to be converted to expected format
+            file_name: used in warnings
+
+        Returns:
+            tuple of 1) dataframe and 2) large conversion indicator:
+                2-column dataframe first column: integers, second column: floats (no NaN)
+                large conversion indicator: if true, the timeseries was large and required conversion
+
         Raises:
             ConversionError: if first data column could not be converted to integer, logged with level "ERROR"
             TypeError: if second data column in given data could not be converted to float or contained NaN,
                 logged with level "ERROR"
         """
+        large_file_indicator = False
         data, additional_columns = data.loc[:, :2], data.loc[:, 2:]
         if not additional_columns.dropna(how="all").empty:
-            log().warning(self._WARN_DATA_IGNORED)
+            log().warning(TimeSeriesManager._WARN_DATA_IGNORED.format(file_name))
         if data.dtypes[0] != "int64":
             if len(data[0]) > FILE_LENGTH_WARN_LIMIT:
-                log().warning(self._WARN_LARGE_CONVERSION.format(identifier))
+                large_file_indicator = True
             data[0] = [FameTime.convert_string_if_is_datetime(time) for time in data[0]]
         if data.dtypes[1] != "float64":
             data[1] = [TimeSeriesManager._assert_float(value) for value in data[1]]
         if data[1].isna().any():
             raise log_error(TypeError(TimeSeriesManager._ERR_NAN_VALUE))
-        return data
+        return data, large_file_indicator
 
     @staticmethod
     def _assert_float(value: Any) -> float:
-        """
-        Converts any given value to a float or raise an Exception
+        """Converts any given value to a float or raise an Exception.
 
         Args:
             value: to be converted to float
@@ -181,7 +214,7 @@ class TimeSeriesManager:
 
     @staticmethod
     def _is_number_string(identifier: str) -> bool:
-        """Returns True if given identifier can be cast to float"""
+        """Returns True if given identifier can be cast to float."""
         try:
             float(identifier)
             return True
@@ -190,8 +223,7 @@ class TimeSeriesManager:
 
     @staticmethod
     def _create_timeseries_from_value(value: int | float) -> tuple[str, pd.DataFrame]:
-        """
-        Returns name and dataframe for a new static timeseries created from the given `value`
+        """Returns name and dataframe for a new static timeseries created from the given `value`.
 
         Args:
             value: the static value of the timeseries to be created
@@ -208,8 +240,7 @@ class TimeSeriesManager:
         return TimeSeriesManager._CONSTANT_IDENTIFIER.format(value), data
 
     def get_series_id_by_identifier(self, identifier: str | int | float) -> int:
-        """
-        Returns id for a previously stored time series by given `identifier`
+        """Returns id for a previously stored time series by given `identifier`.
 
         Args:
             identifier: to get the unique ID for
@@ -225,13 +256,13 @@ class TimeSeriesManager:
         return self._series_by_id.get(identifier)[Entry.ID]  # type: ignore[index]
 
     def get_all_series(self) -> list[tuple[int, str, pd.DataFrame]]:
-        """Returns iterator over id, name and dataframe of all stored series"""
+        """Returns iterator over id, name and dataframe of all stored series."""
         if len(self._series_by_id) == 0:
             log().warning(self._WARN_NO_DATA)
         return [(v[Entry.ID], v[Entry.NAME], v[Entry.DATA]) for v in self._series_by_id.values()]
 
     def reconstruct_time_series(self, timeseries: list[InputData.TimeSeriesDao]) -> None:
-        """Reconstructs and stores time series from given list of `timeseries_dao`"""
+        """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}
@@ -248,7 +279,7 @@ class TimeSeriesManager:
             self._series_by_id[one_series.series_id] = reconstructed
 
     def _get_cleaned_file_name(self, timeseries_name: str) -> str:
-        """Ensure given file name has CSV file ending"""
+        """Ensure given file name has CSV file ending."""
         if Path(timeseries_name).suffix.lower() == CSV_FILE_SUFFIX:
             filename = Path(timeseries_name).name
         else:
@@ -256,8 +287,8 @@ class TimeSeriesManager:
         return str(Path(self._TIMESERIES_RECONSTRUCTION_PATH, filename))
 
     def get_reconstructed_series_by_id(self, series_id: int) -> str:
-        """
-        Return name or path for given `series_id` if series these are identified by their number.
+        """Return name or path for given `series_id` if series these are identified by their number.
+
         Use this only if series were added via `reconstruct_time_series`
 
         Args: