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

fameio/{source → input}/validator.py

@@ -4,20 +4,17 @@
 
 import math
 from collections import Counter
-from typing import Any, Dict, List
+from typing import Any
 
-from fameio.source import PathResolver
-from fameio.source.logs import log_error_and_raise, log
-from fameio.source.scenario import Agent, Attribute, Contract, Scenario
-from fameio.source.scenario.stringset import StringSet
-from fameio.source.schema.agenttype import AgentType
-from fameio.source.schema.attribute import AttributeSpecs, AttributeType
-from fameio.source.schema.schema import Schema
-from fameio.source.series import TimeSeriesManager, TimeSeriesException
-from fameio.source.time import FameTime
+from fameio.input.resolver import PathResolver
+from fameio.input.scenario import Agent, Attribute, Contract, Scenario, StringSet
+from fameio.input.schema import Schema, AttributeSpecs, AttributeType, AgentType
+from fameio.logs import log_error_and_raise, log
+from fameio.series import TimeSeriesManager, TimeSeriesError
+from fameio.time import FameTime
 
 
-class ValidationException(Exception):
+class ValidationError(Exception):
     """Indicates an error occurred during validation of any data with a connected schema"""
 
     pass
@@ -77,12 +74,12 @@ class SchemaValidator:
         return timeseries_manager
 
     @staticmethod
-    def ensure_unique_agent_ids(agents: List[Agent]) -> None:
+    def ensure_unique_agent_ids(agents: list[Agent]) -> None:
         """Raises exception if any id for given `agents` is not unique"""
         list_of_ids = [agent.id for agent in agents]
         non_unique_ids = [agent_id for agent_id, count in Counter(list_of_ids).items() if count > 1]
         if non_unique_ids:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_ID_NOT_UNIQUE.format(non_unique_ids)))
+            log_error_and_raise(ValidationError(SchemaValidator._AGENT_ID_NOT_UNIQUE.format(non_unique_ids)))
 
     @staticmethod
     def ensure_agent_and_timeseries_are_valid(agent: Agent, schema: Schema, timeseries_manager: TimeSeriesManager):
@@ -95,7 +92,7 @@ class SchemaValidator:
     def ensure_agent_type_in_schema(agent: Agent, schema: Schema) -> None:
         """Raises exception if type for given `agent` is not specified in given `schema`"""
         if agent.type_name not in schema.agent_types:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_TYPE_UNKNOWN.format(agent.type_name)))
+            log_error_and_raise(ValidationError(SchemaValidator._AGENT_TYPE_UNKNOWN.format(agent.type_name)))
 
     @staticmethod
     def ensure_is_valid_agent(agent: Agent, schema: Schema) -> None:
@@ -112,10 +109,10 @@ class SchemaValidator:
         if name in schema.agent_types:
             return schema.agent_types[name]
         else:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_TYPE_UNKNOWN.format(name)))
+            log_error_and_raise(ValidationError(SchemaValidator._AGENT_TYPE_UNKNOWN.format(name)))
 
     @staticmethod
-    def _ensure_mandatory_present(attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs]) -> None:
+    def _ensure_mandatory_present(attributes: dict[str, Attribute], specifications: dict[str, AttributeSpecs]) -> None:
         """
         Raises Exception if in given list of `specifications` at least one item is mandatory,
         provides no defaults and is not contained in given `attributes` dictionary
@@ -125,7 +122,7 @@ class SchemaValidator:
                 if specification.is_mandatory:
                     if not specification.has_default_value:
                         log_error_and_raise(
-                            ValidationException(SchemaValidator._ATTRIBUTE_MISSING.format(specification.full_name))
+                            ValidationError(SchemaValidator._ATTRIBUTE_MISSING.format(specification.full_name))
                         )
                 else:
                     if specification.has_default_value:
@@ -141,11 +138,11 @@ class SchemaValidator:
                     SchemaValidator._ensure_mandatory_present(attribute.nested, specification.nested_attributes)
 
     @staticmethod
-    def _ensure_attributes_exist(attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs]) -> None:
+    def _ensure_attributes_exist(attributes: dict[str, Attribute], specifications: dict[str, AttributeSpecs]) -> None:
         """Raises exception any entry of given `attributes` has no corresponding type `specification`"""
         for name, attribute in attributes.items():
             if name not in specifications:
-                log_error_and_raise(ValidationException(SchemaValidator._ATTRIBUTE_UNKNOWN.format(attribute)))
+                log_error_and_raise(ValidationError(SchemaValidator._ATTRIBUTE_UNKNOWN.format(attribute)))
             if attribute.has_nested:
                 specification = specifications[name]
                 SchemaValidator._ensure_attributes_exist(attribute.nested, specification.nested_attributes)
@@ -156,7 +153,7 @@ class SchemaValidator:
 
     @staticmethod
     def _ensure_value_and_type_match(
-        attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs]
+        attributes: dict[str, Attribute], specifications: dict[str, AttributeSpecs]
     ) -> None:
         """Raises exception if in given list of `attributes` its value does not match associated type `specification`"""
         for name, attribute in attributes.items():
@@ -166,10 +163,10 @@ class SchemaValidator:
                 type_spec = specification.attr_type
                 if not SchemaValidator._is_compatible(specification, value):
                     message = SchemaValidator._INCOMPATIBLE.format(value, type_spec, specification.full_name)
-                    log_error_and_raise(ValidationException(message))
+                    log_error_and_raise(ValidationError(message))
                 if not SchemaValidator._is_allowed_value(specification, value):
                     message = SchemaValidator._DISALLOWED.format(value, specification.full_name)
-                    log_error_and_raise(ValidationException(message))
+                    log_error_and_raise(ValidationError(message))
             if attribute.has_nested:
                 SchemaValidator._ensure_value_and_type_match(attribute.nested, specification.nested_attributes)
             if attribute.has_nested_list:
@@ -210,7 +207,7 @@ class SchemaValidator:
         elif attribute_type is AttributeType.TIME_SERIES:
             return isinstance(value, (str, int)) or (isinstance(value, float) and not math.isnan(value))
         else:
-            log_error_and_raise(ValidationException(SchemaValidator._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
+            log_error_and_raise(ValidationError(SchemaValidator._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
 
     @staticmethod
     def _is_allowed_value(attribute: AttributeSpecs, value) -> bool:
@@ -239,7 +236,7 @@ class SchemaValidator:
 
     @staticmethod
     def _ensure_valid_timeseries(
-        attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs], manager: TimeSeriesManager
+        attributes: dict[str, Attribute], specifications: dict[str, AttributeSpecs], manager: TimeSeriesManager
     ) -> None:
         """Recursively searches for time_series in agent attributes and registers them at given `manager`"""
         for name, attribute in attributes.items():
@@ -249,9 +246,9 @@ class SchemaValidator:
                 if attribute_type is AttributeType.TIME_SERIES:
                     try:
                         manager.register_and_validate(attribute.value)
-                    except TimeSeriesException as e:
+                    except TimeSeriesError as e:
                         message = SchemaValidator._TIME_SERIES_INVALID.format(specification.full_name)
-                        log_error_and_raise(ValidationException(message, e))
+                        log_error_and_raise(ValidationError(message, e))
             if attribute.has_nested:
                 SchemaValidator._ensure_valid_timeseries(attribute.nested, specification.nested_attributes, manager)
             if attribute.has_nested_list:
@@ -259,7 +256,7 @@ class SchemaValidator:
                     SchemaValidator._ensure_valid_timeseries(entry, specification.nested_attributes, manager)
 
     @staticmethod
-    def ensure_string_set_consistency(agent: Agent, schema: Schema, string_sets: Dict[str, StringSet]) -> None:
+    def ensure_string_set_consistency(agent: Agent, schema: Schema, string_sets: dict[str, StringSet]) -> None:
         """
         Raises exception if
             a) an agent's attribute is of type StringSet but the corresponding StringSet is not defined in the scenario
@@ -271,7 +268,7 @@ class SchemaValidator:
 
     @staticmethod
     def _ensure_string_set_consistency(
-        attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs], string_sets: Dict[str, StringSet]
+        attributes: dict[str, Attribute], specifications: dict[str, AttributeSpecs], string_sets: dict[str, StringSet]
     ) -> None:
         """
         Recursively iterates through all attributes of an agent, applying tests if attribute type is `StringSet`
@@ -290,10 +287,10 @@ class SchemaValidator:
                             msg = SchemaValidator._MISSING_STRING_SET_ENTRY.format(
                                 attribute.value, str(attribute), name
                             )
-                            log_error_and_raise(ValidationException(msg))
+                            log_error_and_raise(ValidationError(msg))
                     else:
                         msg = SchemaValidator._MISSING_STRING_SET.format(specification.full_name)
-                        log_error_and_raise(ValidationException(msg))
+                        log_error_and_raise(ValidationError(msg))
             if attribute.has_nested:
                 SchemaValidator._ensure_string_set_consistency(
                     attribute.nested, specification.nested_attributes, string_sets
@@ -303,20 +300,20 @@ class SchemaValidator:
                     SchemaValidator._ensure_string_set_consistency(entry, specification.nested_attributes, string_sets)
 
     @staticmethod
-    def ensure_is_valid_contract(contract: Contract, schema: Schema, agent_types_by_id: Dict[int, str]) -> None:
+    def ensure_is_valid_contract(contract: Contract, schema: Schema, agent_types_by_id: dict[int, str]) -> None:
         """Raises exception if given `contract` does not meet the `schema`'s requirements, using `agent_types_by_id`"""
         sender_id = contract.sender_id
         if sender_id not in agent_types_by_id:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_MISSING.format(sender_id)))
+            log_error_and_raise(ValidationError(SchemaValidator._AGENT_MISSING.format(sender_id)))
         if contract.receiver_id not in agent_types_by_id:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_MISSING.format(contract.receiver_id)))
+            log_error_and_raise(ValidationError(SchemaValidator._AGENT_MISSING.format(contract.receiver_id)))
         sender_type_name = agent_types_by_id[sender_id]
         if sender_type_name not in schema.agent_types:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_TYPE_UNKNOWN.format(sender_type_name)))
+            log_error_and_raise(ValidationError(SchemaValidator._AGENT_TYPE_UNKNOWN.format(sender_type_name)))
         sender_type = schema.agent_types[sender_type_name]
         product = contract.product_name
         if product not in sender_type.products:
-            log_error_and_raise(ValidationException(SchemaValidator._PRODUCT_MISSING.format(product, sender_type_name)))
+            log_error_and_raise(ValidationError(SchemaValidator._PRODUCT_MISSING.format(product, sender_type_name)))
 
     @staticmethod
     def check_agents_have_contracts(scenario: Scenario) -> None:

fameio/{source → input}/writer.py

@@ -1,36 +1,29 @@
 # SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
-import sys
 import importlib.metadata as metadata
+import sys
 from pathlib import Path
-from typing import Any, Dict, List, Union
-
-from fameprotobuf.Contract_pb2 import ProtoContract
-from fameprotobuf.DataStorage_pb2 import DataStorage
-from fameprotobuf.ExecutionData_pb2 import ExecutionData
-from fameprotobuf.Field_pb2 import NestedField
-from fameprotobuf.InputFile_pb2 import InputData
-from fameprotobuf.Model_pb2 import ModelData
-
-from fameio.source.logs import log_error_and_raise, log
-from fameio.source.results.reader import Reader
-from fameio.source.scenario import (
-    Agent,
-    Attribute,
-    Contract,
-    GeneralProperties,
-    Scenario,
-)
-from fameio.source.schema import Schema
-from fameio.source.schema.attribute import AttributeSpecs, AttributeType
-from fameio.source.schema.java_packages import JavaPackages
-from fameio.source.series import TimeSeriesManager
-from fameio.source.time import FameTime
-from fameio.source.tools import ensure_is_list
-
-
-class ProtoWriterException(Exception):
+from typing import Any, Union
+
+from fameprotobuf.contract_pb2 import ProtoContract
+from fameprotobuf.data_storage_pb2 import DataStorage
+from fameprotobuf.execution_data_pb2 import ExecutionData
+from fameprotobuf.field_pb2 import NestedField
+from fameprotobuf.input_file_pb2 import InputData
+from fameprotobuf.model_pb2 import ModelData
+
+import fameio
+from fameio.input.scenario import Agent, Attribute, Contract, GeneralProperties, Scenario, StringSet
+from fameio.input.schema import AttributeSpecs, AttributeType, JavaPackages, Schema
+from fameio.logs import log_error_and_raise, log
+from fameio.output.reader import Reader
+from fameio.series import TimeSeriesManager
+from fameio.time import FameTime
+from fameio.tools import ensure_is_list
+
+
+class ProtoWriterError(Exception):
     """Indicates an error during writing of protobuf file"""
 
     pass
@@ -39,7 +32,7 @@ class ProtoWriterException(Exception):
 class ProtoWriter:
     """Writes a given scenario to protobuf file"""
 
-    _FAME_PROTOBUF_STREAM_HEADER = "famecoreprotobufstreamfilev001"  # noqa
+    _FAME_PROTOBUF_STREAM_HEADER = fameio.FILE_HEADER_V2
 
     _TYPE_NOT_IMPLEMENTED = "AttributeType '{}' not implemented."
     _CONTRACT_UNSUPPORTED = (
@@ -72,43 +65,42 @@ class ProtoWriter:
         self._add_contracts(pb_input, scenario.contracts)
         self._set_time_series(pb_input)
         self._set_schema(pb_input, scenario.schema)
+        self._set_string_sets(pb_input, scenario.string_sets)
 
         self._set_java_package_names(pb_data_storage.model, scenario.schema.packages)
-        self._set_execution_versions(pb_data_storage.execution.versions)
+        self._set_execution_versions(pb_data_storage.execution.version_data)
         return pb_data_storage
 
     @staticmethod
     def _set_general_properties(pb_input: InputData, general_properties: GeneralProperties) -> None:
         """Saves a scenario's general properties to specified protobuf `pb_input` container"""
         log().info("Adding General Properties")
-        pb_input.runId = general_properties.run_id
-        pb_input.simulation.startTime = general_properties.simulation_start_time
-        pb_input.simulation.stopTime = general_properties.simulation_stop_time
-        pb_input.simulation.randomSeed = general_properties.simulation_random_seed
-        pb_input.output.interval = general_properties.output_interval
-        pb_input.output.process = general_properties.output_process
-
-    def _add_agents(self, pb_input: InputData, agents: List[Agent], schema: Schema) -> None:
+        pb_input.run_id = general_properties.run_id
+        pb_input.simulation.start_time = general_properties.simulation_start_time
+        pb_input.simulation.stop_time = general_properties.simulation_stop_time
+        pb_input.simulation.random_seed = general_properties.simulation_random_seed
+
+    def _add_agents(self, pb_input: InputData, agents: list[Agent], schema: Schema) -> None:
         """Triggers setting of `agents` to `pb_input`"""
         log().info("Adding Agents")
         for agent in agents:
-            pb_agent = self._set_agent(pb_input.agent.add(), agent)
+            pb_agent = self._set_agent(pb_input.agents.add(), agent)
             attribute_specs = schema.agent_types[agent.type_name].attributes
             self._set_attributes(pb_agent, agent.attributes, attribute_specs)
-            pb_agent.metadata = repr(agent.meta_data)
+            pb_agent.metadata = agent.get_metadata_string()
 
     @staticmethod
     def _set_agent(pb_agent: InputData.AgentDao, agent: Agent) -> InputData.AgentDao:
         """Saves type and id of given `agent` to protobuf `pb_agent` container. Returns given `pb_agent`"""
-        pb_agent.className = agent.type_name
+        pb_agent.class_name = agent.type_name
         pb_agent.id = agent.id
         return pb_agent
 
     def _set_attributes(
         self,
         pb_parent: Union[InputData.AgentDao, NestedField],
-        attributes: Dict[str, Attribute],
-        specs: Dict[str, AttributeSpecs],
+        attributes: dict[str, Attribute],
+        specs: dict[str, AttributeSpecs],
     ) -> None:
         """Assigns `attributes` to protobuf fields of given `pb_parent` - cascades for nested Attributes"""
         values_not_set = [key for key in specs.keys()]
@@ -136,51 +128,51 @@ class ProtoWriter:
     @staticmethod
     def _add_field(pb_parent: Union[InputData.AgentDao, NestedField], name: str) -> NestedField:
         """Returns new field with given `name` that is added to given `pb_parent`"""
-        pb_field = pb_parent.field.add()
-        pb_field.fieldName = name
+        pb_field = pb_parent.fields.add()
+        pb_field.field_name = name
         return pb_field
 
     def _set_attribute(self, pb_field: NestedField, value: Any, attribute_type: AttributeType) -> None:
         """Sets given `value` to given protobuf `pb_field` depending on specified `attribute_type`"""
         if attribute_type is AttributeType.INTEGER:
-            pb_field.intValue.extend(ensure_is_list(value))
+            pb_field.int_values.extend(ensure_is_list(value))
         elif attribute_type is AttributeType.DOUBLE:
-            pb_field.doubleValue.extend(ensure_is_list(value))
+            pb_field.double_values.extend(ensure_is_list(value))
         elif attribute_type is AttributeType.LONG:
-            pb_field.longValue.extend(ensure_is_list(value))
+            pb_field.long_values.extend(ensure_is_list(value))
         elif attribute_type is AttributeType.TIME_STAMP:
-            pb_field.longValue.extend(ensure_is_list(FameTime.convert_string_if_is_datetime(value)))
+            pb_field.long_values.extend(ensure_is_list(FameTime.convert_string_if_is_datetime(value)))
         elif attribute_type in (AttributeType.ENUM, AttributeType.STRING, AttributeType.STRING_SET):
-            pb_field.stringValue.extend(ensure_is_list(value))
+            pb_field.string_values.extend(ensure_is_list(value))
         elif attribute_type is AttributeType.TIME_SERIES:
-            pb_field.seriesId = self._time_series_manager.get_series_id_by_identifier(value)
+            pb_field.series_id = self._time_series_manager.get_series_id_by_identifier(value)
         else:
-            log_error_and_raise(ProtoWriterException(self._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
+            log_error_and_raise(ProtoWriterError(self._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
 
     @staticmethod
-    def _add_contracts(pb_input: InputData, contracts: List[Contract]) -> None:
+    def _add_contracts(pb_input: InputData, contracts: list[Contract]) -> None:
         """Triggers setting of `contracts` to `pb_input`"""
         log().info("Adding Contracts")
         for contract in contracts:
-            pb_contract = ProtoWriter._set_contract(pb_input.contract.add(), contract)
+            pb_contract = ProtoWriter._set_contract(pb_input.contracts.add(), contract)
             ProtoWriter._set_contract_attributes(pb_contract, contract.attributes)
-            pb_contract.metadata = repr(contract.meta_data)
+            pb_contract.metadata = contract.get_metadata_string()
 
     @staticmethod
     def _set_contract(pb_contract: ProtoContract, contract: Contract) -> ProtoContract:
         """Saves given `contract` details to protobuf container `pb_contract`. Returns given `pb_contract`"""
-        pb_contract.senderId = contract.sender_id
-        pb_contract.receiverId = contract.receiver_id
-        pb_contract.productName = contract.product_name
-        pb_contract.firstDeliveryTime = contract.first_delivery_time
-        pb_contract.deliveryIntervalInSteps = contract.delivery_interval
+        pb_contract.sender_id = contract.sender_id
+        pb_contract.receiver_id = contract.receiver_id
+        pb_contract.product_name = contract.product_name
+        pb_contract.first_delivery_time = contract.first_delivery_time
+        pb_contract.delivery_interval_in_steps = contract.delivery_interval
         if contract.expiration_time:
-            pb_contract.expirationTime = contract.expiration_time
+            pb_contract.expiration_time = contract.expiration_time
         return pb_contract
 
     @staticmethod
     def _set_contract_attributes(
-        pb_parent: Union[ProtoContract, NestedField], attributes: Dict[str, Attribute]
+        pb_parent: Union[ProtoContract, NestedField], attributes: dict[str, Attribute]
     ) -> None:
         """Assign (nested) Attributes to given protobuf container `pb_parent`"""
         for name, attribute in attributes.items():
@@ -190,13 +182,13 @@ class ProtoWriter:
             if attribute.has_value:
                 value = attribute.value
                 if isinstance(value, int):
-                    pb_field.intValue.extend([value])
+                    pb_field.int_values.extend([value])
                 elif isinstance(value, float):
-                    pb_field.doubleValue.extend([value])
+                    pb_field.double_values.extend([value])
                 elif isinstance(value, str):
-                    pb_field.stringValue.extend([value])
+                    pb_field.string_values.extend([value])
                 else:
-                    log_error_and_raise(ProtoWriterException(ProtoWriter._CONTRACT_UNSUPPORTED.format(str(attribute))))
+                    log_error_and_raise(ProtoWriterError(ProtoWriter._CONTRACT_UNSUPPORTED.format(str(attribute))))
             elif attribute.has_nested:
                 ProtoWriter._set_contract_attributes(pb_field, attribute.nested)
 
@@ -204,17 +196,11 @@ class ProtoWriter:
         """Adds all time series from TimeSeriesManager to given `pb_input`"""
         log().info("Adding TimeSeries")
         for unique_id, identifier, data in self._time_series_manager.get_all_series():
-            pb_series = pb_input.timeSeries.add()
-            pb_series.seriesId = unique_id
-            pb_series.seriesName = identifier
-            ProtoWriter._add_rows_to_series(pb_series, data)
-
-    @staticmethod
-    def _add_rows_to_series(series: InputData.TimeSeriesDao, data_frame) -> None:
-        for key, value in data_frame.itertuples(index=False):
-            row = series.row.add()
-            row.timeStep = int(key)
-            row.value = value
+            pb_series = pb_input.time_series.add()
+            pb_series.series_id = unique_id
+            pb_series.series_name = identifier
+            pb_series.time_steps.extend(list(data[0]))
+            pb_series.values.extend(list(data[1]))
 
     @staticmethod
     def _set_schema(pb_input: InputData, schema: Schema) -> None:
@@ -222,13 +208,27 @@ class ProtoWriter:
         log().info("Adding Schema")
         pb_input.schema = schema.to_string()
 
+    @staticmethod
+    def _set_string_sets(pb_input: InputData, string_sets: dict[str, StringSet]) -> None:
+        """Adds the given StringSets to given `pb_input`"""
+        for name, string_set in string_sets.items():
+            pb_set = pb_input.string_sets.add()
+            pb_set.name = name
+            for value, specification in string_set.values.items():
+                pb_value = pb_set.values.add()
+                pb_value.name = value
+                if specification.has_metadata():
+                    pb_value.metadata = specification.get_metadata_string()
+            if string_set.has_metadata():
+                pb_set.metadata = string_set.get_metadata_string()
+
     @staticmethod
     def _set_java_package_names(pb_model: ModelData, java_packages: JavaPackages) -> None:
         """Adds given JavaPackages names to given ModelData section"""
-        pb_packages = pb_model.packages
-        pb_packages.agent.extend(java_packages.agents)
-        pb_packages.dataItem.extend(java_packages.data_items)
-        pb_packages.portable.extend(java_packages.portables)
+        pb_packages = pb_model.package_definition
+        pb_packages.agents.extend(java_packages.agents)
+        pb_packages.data_items.extend(java_packages.data_items)
+        pb_packages.portables.extend(java_packages.portables)
 
     def _write_protobuf_to_disk(self, pb_data_storage: DataStorage) -> None:
         """Writes given `protobuf_input_data` to disk"""
@@ -240,12 +240,12 @@ class ProtoWriter:
                 file.write(len(serialised_data_storage).to_bytes(Reader.BYTES_DEFINING_MESSAGE_LENGTH, byteorder="big"))
                 file.write(serialised_data_storage)
         except OSError as e:
-            log_error_and_raise(ProtoWriterException(ProtoWriter._NO_FILE_SPECIFIED.format(self.file_path), e))
+            log_error_and_raise(ProtoWriterError(ProtoWriter._NO_FILE_SPECIFIED.format(self.file_path), e))
         log().info(self._INFO_WRITING_COMPLETED.format(self.file_path))
 
     @staticmethod
-    def _set_execution_versions(pb_versions: ExecutionData.Versions) -> None:
+    def _set_execution_versions(pb_version_data: ExecutionData.VersionData) -> None:
         """Adds version strings for fameio, fameprotobuf, and python to the given Versions message"""
-        pb_versions.fameProtobuf = metadata.version("fameprotobuf")
-        pb_versions.fameIo = metadata.version("fameio")
-        pb_versions.python = sys.version
+        pb_version_data.fame_protobuf = metadata.version("fameprotobuf")
+        pb_version_data.fame_io = metadata.version("fameio")
+        pb_version_data.python = sys.version

fameio/{source/logs.py → logs.py}

@@ -5,7 +5,7 @@
 import logging as pylog
 from enum import Enum
 from pathlib import Path
-from typing import NoReturn, Optional, List
+from typing import Optional
 
 
 class LogLevel(Enum):
@@ -20,8 +20,8 @@ class LogLevel(Enum):
     DEBUG = pylog.DEBUG
 
 
-_loggers: List[pylog.Logger] = []
-_handlers: List[pylog.Handler] = []
+_loggers: list[pylog.Logger] = []
+_handlers: list[pylog.Handler] = []
 
 _FORMAT_NORMAL = "%(asctime)s — %(levelname)s — %(message)s"  # noqa
 _FORMAT_DETAILLED = "%(asctime)s.%(msecs)03d — %(levelname)s — %(module)s:%(funcName)s:%(lineno)d — %(message)s"  # noqa
@@ -42,14 +42,30 @@ def log() -> pylog.Logger:
     return _loggers[0]
 
 
-def log_and_raise_critical(message: str) -> NoReturn:
-    """Raises a critical error and logs with given `error_message`"""
-    log().critical(message)
-    raise Exception(message)
+def log_critical_and_raise(exception: Exception) -> None:
+    """
+    Raises the specified `exception` and logs a critical error with the exception's message
+
+    Args:
+        exception: to be raised and logged at level `critical`
+
+    Raises:
+        Exception: the given exception
+    """
+    log().critical(str(exception))
+    raise exception
 
 
-def log_error_and_raise(exception: Exception) -> NoReturn:
-    """Raises the specified `exception` and logs an error with the same `message`"""
+def log_error_and_raise(exception: Exception) -> None:
+    """
+    Raises the specified `exception` and logs a critical error with the exception's message
+
+    Args:
+        exception: to be raised and logged at level `error`
+
+    Raises:
+        Exception: the given exception
+    """
     log().error(str(exception))
     raise exception
 

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

@@ -1,10 +1,9 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from typing import Union
 
-from typing import List, Dict, Set, Union, Tuple
-
-from fameprotobuf.Services_pb2 import Output
+from fameprotobuf.services_pb2 import Output
 
 
 class AgentType:
@@ -13,42 +12,42 @@ class AgentType:
     def __init__(self, agent_type: Output.AgentType) -> None:
         self._agent_type = agent_type
 
-    def get_simple_column_map(self) -> Dict[int, str]:
+    def get_simple_column_map(self) -> dict[int, str]:
         """Returns dictionary of simple column IDs mapped to their name - ignoring complex columns"""
-        return {field.fieldId: field.fieldName for field in self._agent_type.field if len(field.indexName) == 0}
+        return {field.field_id: field.field_name for field in self._agent_type.fields if len(field.index_names) == 0}
 
-    def get_merged_column_map(self) -> Dict[int, str]:
+    def get_merged_column_map(self) -> dict[int, str]:
         """Returns dictionary of all column IDs mapped to their name merged with names of inner complex columns"""
         column_names = {}
-        for field in self._agent_type.field:
-            if len(field.indexName) == 0:
-                column_names[field.fieldId] = field.fieldName
+        for field in self._agent_type.fields:
+            if len(field.index_names) == 0:
+                column_names[field.field_id] = field.field_name
             else:
-                column_names[field.fieldId] = f"{field.fieldName}_({tuple(field.indexName)}, value)"
+                column_names[field.field_id] = f"{field.field_name}_({tuple(field.index_names)}, value)"
         return column_names
 
-    def get_simple_column_mask(self) -> List[bool]:
+    def get_simple_column_mask(self) -> list[bool]:
         """Returns list of bool - where an entry is True if the output column with the same index is not complex"""
-        return [True if len(field.indexName) == 0 else False for field in self._agent_type.field]
+        return [True if len(field.index_names) == 0 else False for field in self._agent_type.fields]
 
-    def get_complex_column_ids(self) -> Set[int]:
+    def get_complex_column_ids(self) -> set[int]:
         """Returns set of IDs for complex columns, ignoring simple columns"""
-        return set([field.fieldId for field in self._agent_type.field if len(field.indexName) > 0])
+        return set([field.field_id for field in self._agent_type.fields if len(field.index_names) > 0])
 
     def get_column_name_for_id(self, column_index: int) -> Union[str, None]:
         """Returns name of column by given `column_index` or None, if column is not present"""
-        if 0 <= column_index < len(self._agent_type.field):
-            return self._agent_type.field[column_index].fieldName
+        if 0 <= column_index < len(self._agent_type.fields):
+            return self._agent_type.fields[column_index].field_name
         else:
             return None
 
-    def get_inner_columns(self, column_index: int) -> Tuple[str]:
+    def get_inner_columns(self, column_index: int) -> tuple[str, ...]:
         """Returns tuple of inner column names for complex column with given `column_index`"""
-        return tuple(self._agent_type.field[column_index].indexName)
+        return tuple(self._agent_type.fields[column_index].index_names)
 
     def get_class_name(self) -> str:
         """Returns name of class of wrapped agent type"""
-        return self._agent_type.className
+        return self._agent_type.class_name
 
 
 class AgentTypeLog:
@@ -57,11 +56,11 @@ class AgentTypeLog:
     _ERR_AGENT_TYPE_MISSING = "Requested AgentType `{}` not found."
     _ERR_DOUBLE_DEFINITION = "Just one definition allowed per AgentType. Found multiple for {}. File might be corrupt."
 
-    def __init__(self, requested_agents: List[str]) -> None:
+    def __init__(self, requested_agents: list[str]) -> None:
         self._requested_agents = [agent.upper() for agent in requested_agents] if requested_agents else None
         self._requested_agent_types = {}
 
-    def update_agents(self, new_types: Dict[str, Output.AgentType]) -> None:
+    def update_agents(self, new_types: dict[str, Output.AgentType]) -> None:
         """Saves new `agent_types` (if any) contained in given `output` if requested for extraction"""
         if new_types:
             if self._requested_agents: