fameio 2.3.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

fameio/{source/results → output}/conversion.py

@@ -1,41 +1,50 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 
 import math
-from typing import Dict, Optional
+from typing import Optional
 
 import pandas as pd
 
-from fameio.source.cli.options import TimeOptions, MergingOptions
-from fameio.source.logs import log_error_and_raise, log
-from fameio.source.time import ConversionException, FameTime
+from fameio.cli.options import TimeOptions
+from fameio.logs import log_error_and_raise, log
+from fameio.time import ConversionError, FameTime
 
 _ERR_UNIMPLEMENTED = "Time conversion mode '{}' not implemented."
+_ERR_NEGATIVE = "StepsBefore and StepsAfter must be Zero or positive integers"
 
 
-def apply_time_merging(data: Dict[Optional[str], pd.DataFrame], config: Optional[Dict[MergingOptions, int]]) -> None:
+def _apply_time_merging(
+    dataframes: dict[Optional[str], pd.DataFrame], offset: int, period: int, first_positive_focal_point: int
+) -> None:
+    """Applies time merging to `data` based on given `offset`, `period`, and `first_positive_focal_point`"""
+    log().debug(f"Grouping TimeSteps...")
+    for key in dataframes.keys():
+        df = dataframes[key]
+        index_columns = df.index.names
+        df.reset_index(inplace=True)
+        df["TimeStep"] = df["TimeStep"].apply(lambda t: merge_time(t, first_positive_focal_point, offset, period))
+        dataframes[key] = df.groupby(by=index_columns).sum()
+
+
+def apply_time_merging(data: dict[Optional[str], pd.DataFrame], config: Optional[list[int]]) -> None:
     """
     Applies merging of TimeSteps inplace for given `data`
 
     Args:
-        data: one or multiple DataFrames of time series; column `TimeStep` might be modified
-        config: dict of MergingOptions defining how to merge the TimeSteps
-
-    Returns:
-        Nothing - data is modified inplace
+        data: one or multiple DataFrames of time series; depending on the given config, contents might be modified
+        config: three integer values defining how to merge data within a range of time steps
     """
-    if config:
-        log().debug(f"Grouping TimeSteps...")
-        offset = config[MergingOptions.STEPS_BEFORE]
-        period = config[MergingOptions.STEPS_AFTER] + config[MergingOptions.STEPS_BEFORE] + 1
-        first_positive_focal_point = config[MergingOptions.FOCAL_POINT] % period
-        for key in data.keys():
-            df = data[key]
-            index_columns = df.index.names
-            df.reset_index(inplace=True)
-            df["TimeStep"] = df["TimeStep"].apply(lambda t: merge_time(t, first_positive_focal_point, offset, period))
-            data[key] = df.groupby(by=index_columns).sum()
+    if not config or all(v == 0 for v in config):
+        return
+    focal_point, steps_before, steps_after = config
+    if steps_before < 0 or steps_after < 0:
+        raise ValueError(_ERR_NEGATIVE)
+
+    period = steps_before + steps_after + 1
+    first_positive_focal_point = focal_point % period
+    _apply_time_merging(data, offset=steps_before, period=period, first_positive_focal_point=first_positive_focal_point)
 
 
 def merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int:
@@ -54,16 +63,13 @@ def merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int
     return math.floor((time_step + offset - focal_time) / period) * period + focal_time
 
 
-def apply_time_option(data: Dict[Optional[str], pd.DataFrame], mode: TimeOptions) -> None:
+def apply_time_option(data: dict[Optional[str], pd.DataFrame], mode: TimeOptions) -> None:
     """
     Applies time option based on given `mode` inplace of given `data`
 
     Args:
         data: one or multiple DataFrames of time series; column `TimeStep` might be modified (depending on mode)
         mode: name of time conversion mode (derived from Enum)
-
-    Returns:
-        Nothing - data is modified inplace
     """
     if mode == TimeOptions.INT:
         log().debug("No time conversion...")
@@ -72,10 +78,10 @@ def apply_time_option(data: Dict[Optional[str], pd.DataFrame], mode: TimeOptions
     elif mode == TimeOptions.FAME:
         _convert_time_index(data, "%Y-%m-%d_%H:%M:%S")
     else:
-        log_error_and_raise(ConversionException(_ERR_UNIMPLEMENTED.format(mode)))
+        log_error_and_raise(ConversionError(_ERR_UNIMPLEMENTED.format(mode)))
 
 
-def _convert_time_index(data: Dict[Optional[str], pd.DataFrame], datetime_format: str) -> None:
+def _convert_time_index(data: dict[Optional[str], pd.DataFrame], datetime_format: str) -> None:
     """
     Inplace replacement of `TimeStep` column in MultiIndex of each item of `data` from FAME's time steps` to DateTime
     in given `date_format`
@@ -83,9 +89,6 @@ def _convert_time_index(data: Dict[Optional[str], pd.DataFrame], datetime_format
     Args:
         data: one or multiple DataFrames of time series; column `TimeStep` will be modified
         datetime_format: used for the conversion
-
-    Returns:
-        Nothing - data is modified inplace
     """
     log().debug(f"Converting TimeStep to format '{datetime_format}'...")
     for _, df in data.items():

fameio/{source/results → output}/csv_writer.py

@@ -2,14 +2,14 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from pathlib import Path
-from typing import Dict, Union
+from typing import Union
 
 import pandas as pd
 
-from fameio.source.logs import log
-from fameio.source.results.data_transformer import INDEX
-from fameio.source.series import TimeSeriesManager
-from fameio.source.tools import ensure_path_exists
+from fameio.logs import log
+from fameio.output.data_transformer import INDEX
+from fameio.series import TimeSeriesManager
+from fameio.tools import ensure_path_exists
 
 
 class CsvWriter:
@@ -43,7 +43,7 @@ class CsvWriter:
         if not self._output_folder.is_dir():
             self._output_folder.mkdir(parents=True)
 
-    def write_to_files(self, agent_name: str, data: Dict[Union[None, str], pd.DataFrame]) -> None:
+    def write_to_files(self, agent_name: str, data: dict[Union[None, str], pd.DataFrame]) -> None:
         """Writes `data` for given `agent_name` to .csv file(s)"""
         for column_name, column_data in data.items():
             column_data.sort_index(inplace=True)
@@ -91,7 +91,7 @@ class CsvWriter:
         """Returns True if a file for given `identifier` was already written"""
         return identifier in self._files
 
-    def pop_all_file_paths(self) -> Dict[str, Path]:
+    def pop_all_file_paths(self) -> dict[str, Path]:
         """Clears all stored file paths and returns their previous identifiers and their paths"""
         current_files = self._files
         self._files = {}

fameio/{source/results → output}/data_transformer.py

@@ -5,14 +5,14 @@ from __future__ import annotations
 
 from abc import ABC
 from builtins import staticmethod
-from typing import List, Dict, Tuple, Union, Optional
+from typing import Union, Optional
 
 import pandas as pd
-from fameprotobuf.Services_pb2 import Output
+from fameprotobuf.services_pb2 import Output
 from pandas import DataFrame
 
-from fameio.source.cli.options import ResolveOptions
-from fameio.source.results.agent_type import AgentType
+from fameio.cli.options import ResolveOptions
+from fameio.output.agent_type import AgentType
 
 INDEX = ("AgentId", "TimeStep")
 
@@ -31,8 +31,8 @@ class DataTransformer(ABC):
         return DataTransformer.MODES[complex_column_mode]()
 
     def extract_agent_data(
-        self, series: List[Output.Series], agent_type: AgentType
-    ) -> Dict[Optional[str], pd.DataFrame]:
+        self, series: list[Output.Series], agent_type: AgentType
+    ) -> dict[Optional[str], pd.DataFrame]:
         """
         Returns dict of DataFrame(s) containing all data from given `series` of given `agent_type`.
         When ResolveOption is `SPLIT`, the dict maps each complex column's name to the associated DataFrame.
@@ -58,8 +58,8 @@ class DataTransformer(ABC):
         return data_frames
 
     def _extract_agent_data(
-        self, series: List[Output.Series], agent_type: AgentType
-    ) -> Dict[int, Dict[Tuple, List[Union[float, None, str]]]]:
+        self, series: list[Output.Series], agent_type: AgentType
+    ) -> dict[int, dict[tuple, list[Union[float, None, str]]]]:
         """Returns mapping of (agentId, timeStep) to fixed-length list of all output columns for given `class_name`"""
         container = DataTransformer._create_container(agent_type)
         mask_simple = agent_type.get_simple_column_mask()
@@ -69,7 +69,7 @@ class DataTransformer(ABC):
         return filled_columns
 
     @staticmethod
-    def _create_container(agent_type: AgentType) -> Dict[int, Dict]:
+    def _create_container(agent_type: AgentType) -> dict[int, dict]:
         """Returns map of complex columns IDs to an empty dict, and one more for the remaining simple columns"""
         field_ids = agent_type.get_complex_column_ids().union([DataTransformer.SIMPLE_COLUMN_INDEX])
         return {field_id: {} for field_id in field_ids}
@@ -77,34 +77,34 @@ class DataTransformer(ABC):
     def _add_series_data(
         self,
         series: Output.Series,
-        mask_simple: List[bool],
-        container: Dict[int, Dict[Tuple, List[Union[float, None, str]]]],
+        mask_simple: list[bool],
+        container: dict[int, dict[tuple, list[Union[float, None, str]]]],
     ) -> None:
         """Adds data from given `series` to specified `container` dict as list"""
-        empty_list = [None] * len(mask_simple)
-        for line in series.line:
-            index = (series.agentId, line.timeStep)
+        empty_list: list = [None] * len(mask_simple)
+        for line in series.lines:
+            index = (series.agent_id, line.time_step)
             simple_values = empty_list.copy()
-            for column in line.column:
-                if mask_simple[column.fieldId]:
-                    simple_values[column.fieldId] = column.value
+            for column in line.columns:
+                if mask_simple[column.field_id]:
+                    simple_values[column.field_id] = column.value
                 else:
                     self._merge_complex_column(column, simple_values)
                     self._store_complex_values(column, container, index)
             container[DataTransformer.SIMPLE_COLUMN_INDEX][index] = simple_values
 
     @staticmethod
-    def _merge_complex_column(column: Output.Series.Line.Column, values: List) -> None:
+    def _merge_complex_column(column: Output.Series.Line.Column, values: list) -> None:
         """Does not merge complex column data"""
         pass
 
     @staticmethod
-    def _store_complex_values(column: Output.Series.Line.Column, container: Dict[int, Dict], index: Tuple) -> None:
+    def _store_complex_values(column: Output.Series.Line.Column, container: dict[int, dict], index: tuple) -> None:
         """Does not store complex column data"""
         pass
 
     @staticmethod
-    def _get_column_map(agent_type: AgentType) -> Dict[int, str]:
+    def _get_column_map(agent_type: AgentType) -> dict[int, str]:
         """Returns mapping of simple column IDs to their name for given `agent_type`"""
         return agent_type.get_simple_column_map()
 
@@ -115,8 +115,8 @@ class DataTransformerIgnore(DataTransformer):
 
 class DataTransformerSplit(DataTransformer):
     @staticmethod
-    def _store_complex_values(column: Output.Series.Line.Column, container: Dict[int, Dict], base_index: Tuple) -> None:
+    def _store_complex_values(column: Output.Series.Line.Column, container: dict[int, dict], base_index: tuple) -> None:
         """Adds inner data from `column` to given `container` - split by column type"""
-        for entry in column.entry:
-            index = base_index + tuple(entry.indexValue)
-            container[column.fieldId][index] = entry.value
+        for entry in column.entries:
+            index = base_index + tuple(entry.index_values)
+            container[column.field_id][index] = entry.value

fameio/{source/results → output}/input_dao.py

@@ -2,20 +2,20 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 import ast
-from typing import List, Dict, Any, Optional, Tuple
+from typing import Any, Optional
 
-from fameprotobuf.DataStorage_pb2 import DataStorage
-from fameprotobuf.Field_pb2 import NestedField
-from fameprotobuf.InputFile_pb2 import InputData
+from fameprotobuf.data_storage_pb2 import DataStorage
+from fameprotobuf.field_pb2 import NestedField
+from fameprotobuf.input_file_pb2 import InputData
 
-from fameio.source.logs import log
-from fameio.source.scenario import GeneralProperties, Agent, Contract, Scenario
-from fameio.source.schema import Schema, AttributeSpecs, AttributeType
-from fameio.source.series import TimeSeriesManager
+from fameio.input.scenario import GeneralProperties, Agent, Contract, Scenario
+from fameio.input.schema import Schema, AttributeSpecs, AttributeType
+from fameio.logs import log
+from fameio.series import TimeSeriesManager
 
 
-class InputConversionException(Exception):
-    """An Exception indication an error during reconstruction of input from its protobuf representation"""
+class InputConversionError(Exception):
+    """Indicates an error during reconstruction of input from its protobuf representation"""
 
     pass
 
@@ -26,22 +26,24 @@ class InputDao:
     _ERR_NO_INPUTS = "No input data found on file."
     _ERR_MULTIPLE_INPUTS = "File corrupt. More than one input section found on file."
 
-    _FIELD_NAME_MAP: Dict = {
-        AttributeType.STRING: "stringValue",
-        AttributeType.ENUM: "stringValue",
-        AttributeType.INTEGER: "intValue",
-        AttributeType.DOUBLE: "doubleValue",
-        AttributeType.LONG: "longValue",
-        AttributeType.TIME_SERIES: "seriesId",
-        AttributeType.BLOCK: "field",
+    _FIELD_NAME_MAP: dict = {
+        AttributeType.STRING: "string_values",
+        AttributeType.STRING_SET: "string_values",
+        AttributeType.ENUM: "string_values",
+        AttributeType.INTEGER: "int_values",
+        AttributeType.DOUBLE: "double_values",
+        AttributeType.LONG: "long_values",
+        AttributeType.TIME_STAMP: "long_values",
+        AttributeType.TIME_SERIES: "series_id",
+        AttributeType.BLOCK: "fields",
     }
 
     def __init__(self) -> None:
-        self._inputs: List[InputData] = []
+        self._inputs: list[InputData] = []
         self._timeseries_manager: TimeSeriesManager = TimeSeriesManager()
         self._schema: Optional[Schema] = None
 
-    def store_inputs(self, data_storages: List[DataStorage]) -> None:
+    def store_inputs(self, data_storages: list[DataStorage]) -> None:
         """
         Extracts and stores Inputs in given DataStorages - if such are present
 
@@ -50,7 +52,7 @@ class InputDao:
         """
         self._inputs.extend([data_storage.input for data_storage in data_storages if data_storage.HasField("input")])
 
-    def recover_inputs(self) -> Tuple[TimeSeriesManager, Scenario]:
+    def recover_inputs(self) -> tuple[TimeSeriesManager, Scenario]:
         """
         Recovers inputs to GeneralProperties, Schema, Agents, Contracts, Timeseries
 
@@ -81,10 +83,10 @@ class InputDao:
         """
         if not self._inputs:
             log().error(self._ERR_NO_INPUTS)
-            raise InputConversionException(self._ERR_NO_INPUTS)
+            raise InputConversionError(self._ERR_NO_INPUTS)
         if len(self._inputs) > 1:
             log().error(self._ERR_MULTIPLE_INPUTS)
-            raise InputConversionException(self._ERR_MULTIPLE_INPUTS)
+            raise InputConversionError(self._ERR_MULTIPLE_INPUTS)
         return self._inputs[0]
 
     @staticmethod
@@ -96,53 +98,53 @@ class InputDao:
     def _get_general_properties(input_data: InputData) -> GeneralProperties:
         """Read and return GeneralProperties from given `input_data`"""
         return GeneralProperties(
-            run_id=input_data.runId,
-            simulation_start_time=input_data.simulation.startTime,
-            simulation_stop_time=input_data.simulation.stopTime,
-            simulation_random_seed=input_data.simulation.randomSeed,
-            output_process=input_data.output.process,
-            output_interval=input_data.output.interval,
+            run_id=input_data.run_id,
+            simulation_start_time=input_data.simulation.start_time,
+            simulation_stop_time=input_data.simulation.stop_time,
+            simulation_random_seed=input_data.simulation.random_seed,
         )
 
     @staticmethod
-    def _get_contracts(input_data: InputData) -> List[Contract]:
+    def _get_contracts(input_data: InputData) -> list[Contract]:
         """Read and return Contracts from given `input_data`"""
         return [
             Contract(
-                sender_id=contract.senderId,
-                receiver_id=contract.receiverId,
-                product_name=contract.productName,
-                delivery_interval=contract.deliveryIntervalInSteps,
-                first_delivery_time=contract.firstDeliveryTime,
-                expiration_time=contract.expirationTime,
-                meta_data=ast.literal_eval(contract.metadata),
+                sender_id=contract.sender_id,
+                receiver_id=contract.receiver_id,
+                product_name=contract.product_name,
+                delivery_interval=contract.delivery_interval_in_steps,
+                first_delivery_time=contract.first_delivery_time,
+                expiration_time=contract.expiration_time,
+                metadata=ast.literal_eval(contract.metadata) if contract.metadata else None,
             )
-            for contract in input_data.contract
+            for contract in input_data.contracts
         ]
 
     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.timeSeries))
+        self._timeseries_manager.reconstruct_time_series(list(input_data.time_series))
 
-    def _get_agents(self, input_data: InputData) -> List[Agent]:
+    def _get_agents(self, input_data: InputData) -> list[Agent]:
         """Read and return Agents from given `input_data`"""
         agents = []
-        for agent_dao in input_data.agent:
+        for agent_dao in input_data.agents:
             agent = Agent(
-                agent_id=agent_dao.id, type_name=agent_dao.className, meta_data=ast.literal_eval(agent_dao.metadata)
+                agent_id=agent_dao.id,
+                type_name=agent_dao.class_name,
+                metadata=ast.literal_eval(agent_dao.metadata) if agent_dao.metadata else None,
             )
             attribute_dict = self._get_attributes(
-                list(agent_dao.field), self._schema.agent_types[agent_dao.className].attributes
+                list(agent_dao.fields), self._schema.agent_types[agent_dao.class_name].attributes
             )
             agent.init_attributes_from_dict(attribute_dict)
             agents.append(agent)
         return agents
 
-    def _get_attributes(self, fields: List[NestedField], schematics: Dict[str, AttributeSpecs]) -> Dict[str, Any]:
+    def _get_attributes(self, fields: list[NestedField], schematics: dict[str, AttributeSpecs]) -> dict[str, Any]:
         """Read and return Attributes as Dictionary from given list of fields"""
-        attributes: Dict[str, Any] = {}
+        attributes: dict[str, Any] = {}
         for field in fields:
-            attributes[field.fieldName] = self._get_field_value(field, schematics[field.fieldName])
+            attributes[field.field_name] = self._get_field_value(field, schematics[field.field_name])
         return attributes
 
     def _get_field_value(self, field: NestedField, schematic: AttributeSpecs) -> Any:
@@ -150,12 +152,12 @@ class InputDao:
         attribute_type: AttributeType = schematic.attr_type
         value = field.__getattribute__(self._FIELD_NAME_MAP[attribute_type])
         if attribute_type is AttributeType.TIME_SERIES:
-            return self._timeseries_manager.get_reconstructed_series_by_id(field.seriesId)
+            return self._timeseries_manager.get_reconstructed_series_by_id(field.series_id)
         elif attribute_type is AttributeType.BLOCK:
             if schematic.is_list:
-                return [self._get_attributes(list(entry.field), schematic.nested_attributes) for entry in field.field]
+                return [self._get_attributes(list(entry.fields), schematic.nested_attributes) for entry in field.fields]
             else:
-                return self._get_attributes(list(field.field), schematic.nested_attributes)
+                return self._get_attributes(list(field.fields), schematic.nested_attributes)
         else:
             if schematic.is_list:
                 return list(value)

fameio/{source/results → output}/output_dao.py

@@ -1,51 +1,50 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
-
-from typing import List, Dict, Iterable, Optional
+from typing import Iterable, Optional
 
 import pandas as pd
-from fameprotobuf.DataStorage_pb2 import DataStorage
-from fameprotobuf.Services_pb2 import Output
+from fameprotobuf.data_storage_pb2 import DataStorage
+from fameprotobuf.services_pb2 import Output
 
-from fameio.source.results.agent_type import AgentTypeLog
-from fameio.source.results.data_transformer import DataTransformer
+from fameio.output.agent_type import AgentTypeLog
+from fameio.output.data_transformer import DataTransformer
 
 
 class OutputDAO:
     """Grants convenient access to content of Output protobuf messages for given DataStorages"""
 
-    def __init__(self, data_storages: List[DataStorage], agent_type_log: AgentTypeLog) -> None:
+    def __init__(self, data_storages: list[DataStorage], agent_type_log: AgentTypeLog) -> None:
         self._agent_type_log = agent_type_log
         outputs = self._extract_output_from_data_storages(data_storages)
         self._agent_type_log.update_agents(self._extract_new_agent_types(outputs))
         self._all_series = self._extract_series(outputs)
 
     @staticmethod
-    def _extract_output_from_data_storages(data_storages: List[DataStorage]) -> List[Output]:
+    def _extract_output_from_data_storages(data_storages: list[DataStorage]) -> list[Output]:
         """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]:
+    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`"""
-        list_of_agent_type_lists = [output.agentType for output in outputs if len(output.agentType) > 0]
+        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.className: item for item in list_of_agent_types}
+        return {item.class_name: item for item in list_of_agent_types}
 
     @staticmethod
-    def _extract_series(outputs: List[Output]) -> Dict[str, List[Output.Series]]:
+    def _extract_series(outputs: list[Output]) -> dict[str, list[Output.Series]]:
         """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]
 
         series_per_class_name = {}
         for series in list_of_series:
-            if series.className not in series_per_class_name:
-                series_per_class_name[series.className] = []
-            series_per_class_name[series.className].append(series)
+            if series.class_name not in series_per_class_name:
+                series_per_class_name[series.class_name] = []
+            series_per_class_name[series.class_name].append(series)
         return series_per_class_name
 
     def get_sorted_agents_to_extract(self) -> Iterable[str]:
@@ -54,13 +53,13 @@ class OutputDAO:
         filtered_series = [agent_name for agent_name in all_series if self._agent_type_log.is_requested(agent_name)]
         return iter(filtered_series)
 
-    def _get_agent_names_by_series_count_ascending(self) -> List[str]:
+    def _get_agent_names_by_series_count_ascending(self) -> list[str]:
         """Returns list of agent type names sorted by their amount of series"""
         length_per_agent_types = {agent_name: len(value) for agent_name, value in self._all_series.items()}
         sorted_dict = sorted(length_per_agent_types.items(), key=lambda item: item[1])
         return [agent_name for agent_name, _ in sorted_dict]
 
-    def get_agent_data(self, agent_name: str, data_transformer: DataTransformer) -> Dict[Optional[str], pd.DataFrame]:
+    def get_agent_data(self, agent_name: str, data_transformer: DataTransformer) -> dict[Optional[str], pd.DataFrame]:
         """
         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),

fameio/{source/results → output}/reader.py

@@ -4,14 +4,20 @@
 from __future__ import annotations
 
 import struct
-import typing
 from abc import ABC, abstractmethod
-from typing import IO, List
+from typing import IO, final, NoReturn
 
-from fameprotobuf.DataStorage_pb2 import DataStorage
+from fameprotobuf.data_storage_pb2 import DataStorage
 from google.protobuf.message import DecodeError
 
-from fameio.source.logs import log
+import fameio
+from fameio.logs import log, log_critical_and_raise
+
+
+class ProtobufReaderError(Exception):
+    """Indicates an error while reading a protobuf file"""
+
+    pass
 
 
 class Reader(ABC):
@@ -27,16 +33,27 @@ class Reader(ABC):
     _HEADER_LENGTH = 30
     HEADER_ENCODING = "utf-8"
     BYTES_DEFINING_MESSAGE_LENGTH = 4
+
+    _ERR_DEPRECATED_V0 = "Cannot read file: File was created with `FAME-Core` version <1.4 or `fameio` version < 1.6"
+    _ERR_DEPRECATED_V1 = "Cannot read file: File was created with `FAME-Core` version <2.0 or `fameio` version < 3.0"
+
     _READER_HEADERS = {
-        "famecoreprotobufstreamfilev001": lambda file, mode: ReaderV1(file, mode),  # noqa
+        None: lambda file, mode: Reader._raise_error(Reader._ERR_DEPRECATED_V0),
+        fameio.FILE_HEADER_V1: lambda file, mode: Reader._raise_error(Reader._ERR_DEPRECATED_V1),
+        fameio.FILE_HEADER_V2: lambda file, mode: ReaderV2(file, mode),
     }
 
+    @staticmethod
+    @final
+    def _raise_error(error_message: str) -> NoReturn:
+        log_critical_and_raise(ProtobufReaderError(error_message))
+
     def __init__(self, file: IO, read_single) -> None:
         self._file = file
         self._read_single = read_single
 
     @abstractmethod
-    def read(self) -> List[DataStorage]:
+    def read(self) -> list[DataStorage]:
         """Reads associated filestream and returns one or multiple DataStorage(s) or empty list"""
 
     @staticmethod
@@ -56,13 +73,9 @@ class Reader(ABC):
             header = file.read(Reader._HEADER_LENGTH).decode(Reader.HEADER_ENCODING)
             return Reader._READER_HEADERS[header](file, read_single)
         except (KeyError, UnicodeDecodeError):
-            log().warning(Reader._WARN_NO_HEADER)
-            file.seek(0)
-            if read_single:
-                log().error(Reader._ERR_UNSUPPORTED_MODE)
-            return ReaderV0(file, False)
+            return Reader._READER_HEADERS[None](file, read_single)
 
-    @typing.final
+    @final
     def _read_message_length(self) -> int:
         """Returns length of next DataStorage message in file"""
         message_length_byte = self._file.read(self.BYTES_DEFINING_MESSAGE_LENGTH)
@@ -73,7 +86,7 @@ class Reader(ABC):
             message_length_int = struct.unpack(">i", message_length_byte)[0]
         return message_length_int
 
-    @typing.final
+    @final
     def _read_data_storage_message(self, message_length: int = None) -> DataStorage:
         """
         Returns given `data_storage` read from current file position and following `message_length` bytes.
@@ -90,7 +103,7 @@ class Reader(ABC):
         return self._parse_to_data_storage(message) if message else None
 
     @staticmethod
-    @typing.final
+    @final
     def _parse_to_data_storage(message: bytes) -> DataStorage:
         data_storage = DataStorage()
         try:
@@ -100,24 +113,10 @@ class Reader(ABC):
         return data_storage
 
 
-class ReaderV0(Reader):
-    """Reader class for deprecated `fame-core<1.4` output without any header"""
-
-    _WARN_DEPRECATED = "DeprecationWarning: Please consider updating to `FAME-Core>=1.4` and `fameio>=1.6`"
-
-    def __init__(self, file: IO, read_single):
-        super().__init__(file, read_single)
-        log().warning(self._WARN_DEPRECATED)
-
-    def read(self) -> List[DataStorage]:
-        result = self._read_data_storage_message()
-        return [result] if result else []
-
-
-class ReaderV1(Reader):
-    """Reader class for `fame-core>=1.4` output with header of version v001"""
+class ReaderV2(Reader):
+    """Reader class for `fame-core>=2.0` output with header of version v002"""
 
-    def read(self) -> List[DataStorage]:
+    def read(self) -> list[DataStorage]:
         messages = []
         while True:
             message_length = self._read_message_length()

fameio/{source/results → output}/yaml_writer.py

@@ -2,17 +2,16 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from pathlib import Path
-from typing import Dict
 
 import yaml
 
-from fameio.source.logs import log
+from fameio.logs import log
 
 ERR_WRITE_EXCEPTION = "Failed to save dictionary to YAML file `{}`"
 INFO_DESTINATION = "Saving scenario to file at {}"
 
 
-def data_to_yaml_file(data: Dict, file_path: Path) -> None:
+def data_to_yaml_file(data: dict, file_path: Path) -> None:
     """
     Save the given data to a YAML file at given path