fameio 3.1.1__py3-none-any.whl → 3.3.0__py3-none-any.whl

fameio/input/writer.py

@@ -1,10 +1,12 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
-from importlib import metadata
+from __future__ import annotations
+
 import sys
+from importlib import metadata
 from pathlib import Path
-from typing import Any, Union
+from typing import Any
 
 from fameprotobuf.contract_pb2 import ProtoContract
 from fameprotobuf.data_storage_pb2 import DataStorage
@@ -12,33 +14,37 @@ 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
+from google.protobuf.message import EncodeError
 
 import fameio
+from fameio.input import InputError
 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.logs import log, log_error
 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"""
+class ProtoWriterError(InputError):
+    """Indicates an error during writing of a protobuf file."""
 
 
 class ProtoWriter:
-    """Writes a given scenario to protobuf file"""
+    """Writes a given scenario to protobuf file."""
 
     _FAME_PROTOBUF_STREAM_HEADER = fameio.FILE_HEADER_V2
 
-    _TYPE_NOT_IMPLEMENTED = "AttributeType '{}' not implemented."
+    _TYPE_NOT_IMPLEMENTED = "Protobuf representation for AttributeType '{}' not implemented."
     _CONTRACT_UNSUPPORTED = (
         "Unsupported value for Contract Attribute '{}'; "
         "Only support `int`, `float`, `enum` or `dict` types are supported here."
     )
     _USING_DEFAULT = "Using provided Default for Attribute: '{}'."
-    _NO_FILE_SPECIFIED = "Could not write to '{}'. Please specify a valid output file."
+    _ERR_FILE_PATH = "Could not open file '{}' for writing. Please specify a valid output file."
+    _ERR_PROTOBUF_ENCODING = "Could not encode to protobuf. Please contact FAME-Io developers: fame@dlr.de"
+    _ERR_FILE_WRITE = "Could not write to file '{}'."
 
     _INFO_WRITING = "Writing scenario to protobuf file `{}`"
     _INFO_WRITING_COMPLETED = "Saved protobuf file `{}` to disk"
@@ -48,12 +54,30 @@ class ProtoWriter:
         self._time_series_manager: TimeSeriesManager = time_series_manager
 
     def write_validated_scenario(self, scenario: Scenario) -> None:
-        """Writes given validated Scenario to file"""
-        pb_data_storage = self._create_protobuf_from_scenario(scenario)
-        self._write_protobuf_to_disk(pb_data_storage)
+        """Writes given validated Scenario to file.
+
+        Args:
+            scenario: to be written to file
+
+        Raises:
+            ProtoWriterError: if scenario could not be written to file, logged with level "ERROR"
+        """
+        data_storage = self._create_protobuf_from_scenario(scenario)
+        serialised = self._serialise(data_storage)
+        self._write_data_to_disk(serialised)
 
     def _create_protobuf_from_scenario(self, scenario: Scenario) -> DataStorage:
-        """Returns given `scenario` written to new DataStorage protobuf"""
+        """Returns given `scenario` written to new DataStorage protobuf.
+
+        Args:
+            scenario: to be converted to protobuf
+
+        Returns:
+            protobuf container with the scenario
+
+        Raises:
+            ProtoWriterError: if the protobuf representation cannot be constructed, logged with level "ERROR"
+        """
         log().info("Converting scenario to protobuf.")
         pb_data_storage = DataStorage()
         pb_input = pb_data_storage.input
@@ -71,7 +95,7 @@ class ProtoWriter:
 
     @staticmethod
     def _set_general_properties(pb_input: InputData, general_properties: GeneralProperties) -> None:
-        """Saves a scenario's general properties to specified protobuf `pb_input` container"""
+        """Saves a scenario's general properties to specified protobuf `pb_input` container."""
         log().info("Adding General Properties")
         pb_input.run_id = general_properties.run_id
         pb_input.simulation.start_time = general_properties.simulation_start_time
@@ -79,7 +103,16 @@ class ProtoWriter:
         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`"""
+        """Triggers setting of `agents` to `pb_input`.
+
+        Args:
+            pb_input: parent element to add the agents to
+            agents: to be added to parent input
+            schema: describing the agents' attributes
+
+        Raises:
+            ProtoWriterError: if any agent's attributes cannot be set, logged with level "ERROR"
+        """
         log().info("Adding Agents")
         for agent in agents:
             pb_agent = self._set_agent(pb_input.agents.add(), agent)
@@ -89,18 +122,27 @@ class ProtoWriter:
 
     @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`"""
+        """Saves type and id of given `agent` to protobuf `pb_agent` container. Returns given `pb_agent`."""
         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],
+        pb_parent: InputData.AgentDao | NestedField,
         attributes: dict[str, Attribute],
         specs: dict[str, AttributeSpecs],
     ) -> None:
-        """Assigns `attributes` to protobuf fields of given `pb_parent` - cascades for nested Attributes"""
+        """Assigns `attributes` to protobuf fields of given `pb_parent` - cascades for nested Attributes.
+
+        Args:
+            pb_parent: to store the attributes in
+            attributes: to be stored
+            specs: attribute specifications associated with attributes
+
+        Raises:
+            ProtoWriterError: if any attribute cannot be set, logged with level "ERROR"
+        """
         values_not_set = list(specs.keys())
         for name, attribute in attributes.items():
             pb_field = self._add_field(pb_parent, name)
@@ -124,14 +166,23 @@ class ProtoWriter:
                 log().info(self._USING_DEFAULT.format(name))
 
     @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`"""
+    def _add_field(pb_parent: InputData.AgentDao | NestedField, name: str) -> NestedField:
+        """Returns new field with given `name` that is added to given `pb_parent`."""
         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`"""
+        """Sets given `value` to given protobuf `pb_field` depending on specified `attribute_type`.
+
+        Args:
+            pb_field: parent element to contain the attribute value therein
+            value: of the attribute
+            attribute_type: type of the attribute
+
+        Raises:
+            ProtoWriterError: if the attribute type has no serialisation implementation, logged with level "ERROR"
+        """
         if attribute_type is AttributeType.INTEGER:
             pb_field.int_values.extend(ensure_is_list(value))
         elif attribute_type is AttributeType.DOUBLE:
@@ -145,11 +196,19 @@ class ProtoWriter:
         elif attribute_type is AttributeType.TIME_SERIES:
             pb_field.series_id = self._time_series_manager.get_series_id_by_identifier(value)
         else:
-            log_error_and_raise(ProtoWriterError(self._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
+            raise log_error(ProtoWriterError(self._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
 
     @staticmethod
     def _add_contracts(pb_input: InputData, contracts: list[Contract]) -> None:
-        """Triggers setting of `contracts` to `pb_input`"""
+        """Adds given contracts to input data.
+
+        Args:
+            pb_input: parent element to have the contracts added to
+            contracts: to be added
+
+        Raises:
+            ProtoWriterError: if any contract cannot be added, logged with level "ERROR"
+        """
         log().info("Adding Contracts")
         for contract in contracts:
             pb_contract = ProtoWriter._set_contract(pb_input.contracts.add(), contract)
@@ -158,7 +217,7 @@ class ProtoWriter:
 
     @staticmethod
     def _set_contract(pb_contract: ProtoContract, contract: Contract) -> ProtoContract:
-        """Saves given `contract` details to protobuf container `pb_contract`. Returns given `pb_contract`"""
+        """Saves given `contract` details to protobuf container `pb_contract`. Returns given `pb_contract`."""
         pb_contract.sender_id = contract.sender_id
         pb_contract.receiver_id = contract.receiver_id
         pb_contract.product_name = contract.product_name
@@ -169,10 +228,16 @@ class ProtoWriter:
         return pb_contract
 
     @staticmethod
-    def _set_contract_attributes(
-        pb_parent: Union[ProtoContract, NestedField], attributes: dict[str, Attribute]
-    ) -> None:
-        """Assign (nested) Attributes to given protobuf container `pb_parent`"""
+    def _set_contract_attributes(pb_parent: ProtoContract | NestedField, attributes: dict[str, Attribute]) -> None:
+        """Assign (nested) Attributes to given protobuf container `pb_parent`.
+
+        Args:
+            pb_parent: parent element, either a contract or an attribute
+            attributes: to be set as child elements of parent
+
+        Raises:
+            ProtoWriterError: if a type unsupported for contract attributes is found, logged with level "ERROR"
+        """
         for name, attribute in attributes.items():
             log().debug(f"Assigning contract attribute `{name}`.")
             pb_field = ProtoWriter._add_field(pb_parent, name)
@@ -186,12 +251,12 @@ class ProtoWriter:
                 elif isinstance(value, str):
                     pb_field.string_values.extend([value])
                 else:
-                    log_error_and_raise(ProtoWriterError(ProtoWriter._CONTRACT_UNSUPPORTED.format(str(attribute))))
+                    raise log_error(ProtoWriterError(ProtoWriter._CONTRACT_UNSUPPORTED.format(str(attribute))))
             elif attribute.has_nested:
                 ProtoWriter._set_contract_attributes(pb_field, attribute.nested)
 
     def _set_time_series(self, pb_input: InputData) -> None:
-        """Adds all time series from TimeSeriesManager to given `pb_input`"""
+        """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.time_series.add()
@@ -202,13 +267,13 @@ class ProtoWriter:
 
     @staticmethod
     def _set_schema(pb_input: InputData, schema: Schema) -> None:
-        """Sets the given `schema` `pb_input`"""
+        """Sets the given `schema` `pb_input`."""
         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`"""
+        """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
@@ -222,28 +287,54 @@ class ProtoWriter:
 
     @staticmethod
     def _set_java_package_names(pb_model: ModelData, java_packages: JavaPackages) -> None:
-        """Adds given JavaPackages names to given ModelData section"""
+        """Adds given JavaPackages names to given ModelData section."""
         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"""
-        log().info(self._INFO_WRITING.format(self.file_path))
-        try:
-            with open(self.file_path, "wb") as file:
-                serialised_data_storage = pb_data_storage.SerializeToString()
-                file.write(self._FAME_PROTOBUF_STREAM_HEADER.encode(Reader.HEADER_ENCODING))
-                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(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_version_data: ExecutionData.VersionData) -> None:
-        """Adds version strings for fameio, fameprotobuf, and python to the given Versions message"""
+        """Adds version strings for fameio, fameprotobuf, and python to the given Versions message."""
         pb_version_data.fame_protobuf = metadata.version("fameprotobuf")
         pb_version_data.fame_io = metadata.version("fameio")
         pb_version_data.python = sys.version
+
+    def _serialise(self, data_storage: DataStorage) -> bytes:
+        """Serialise given data storage to bytes.
+
+        Args:
+            data_storage: to be serialised
+
+        Returns:
+            binary string representation of given data storage
+
+        Raises:
+            ProtoWriterError: if given data storage could not be serialised, logged with level "ERROR"
+        """
+        try:
+            return data_storage.SerializeToString()
+        except EncodeError as e:
+            raise log_error(ProtoWriterError(self._ERR_PROTOBUF_ENCODING)) from e
+
+    def _write_data_to_disk(self, serialised_data: bytes) -> None:
+        """Writes given serialised data to file.
+
+        Args:
+            serialised_data: to be written to file
+
+        Raises:
+            ProtoWriterError: if file could not be opened or written, logged with level "ERROR"
+        """
+        log().info(self._INFO_WRITING.format(self.file_path))
+        try:
+            with open(self.file_path, "wb") as file:
+                try:
+                    file.write(self._FAME_PROTOBUF_STREAM_HEADER.encode(Reader.HEADER_ENCODING))
+                    file.write(len(serialised_data).to_bytes(Reader.BYTES_DEFINING_MESSAGE_LENGTH, byteorder="big"))
+                    file.write(serialised_data)
+                except IOError as e:
+                    raise log_error(ProtoWriterError(self._ERR_FILE_WRITE.format(self.file_path))) from e
+        except OSError as e:
+            raise log_error(ProtoWriterError(ProtoWriter._ERR_FILE_PATH.format(self.file_path), e)) from e
+        log().info(self._INFO_WRITING_COMPLETED.format(self.file_path))

fameio/logs.py

@@ -1,15 +1,16 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import logging as pylog
 from enum import Enum
 from pathlib import Path
-from typing import Optional
+from typing import TypeVar
 
 
 class LogLevel(Enum):
-    """Levels for Logging"""
+    """Levels for Logging."""
 
     PRINT = 100
     CRITICAL = pylog.CRITICAL
@@ -33,80 +34,60 @@ _WARN_NOT_INITIALIZED = "Logger for fameio not initialised: using default log le
 LOGGER_NAME = "fameio"
 DEFAULT_LOG_LEVEL = LogLevel.WARNING
 
+T = TypeVar("T", bound=Exception)
+
 
 def log() -> pylog.Logger:
-    """Returns already set up FAME-Io's logger or - if not set up - a new logger with `WARNING`"""
+    """Returns already set up FAME-Io's logger or - if not set up - a new logger with `WARNING`."""
     if not _loggers:
         fameio_logger(DEFAULT_LOG_LEVEL.name)
         pylog.warning(_WARN_NOT_INITIALIZED)
     return _loggers[0]
 
 
-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_critical(exception: T) -> T:
+    """Logs a critical error with the exception's message and returns the exception for raising it.
 
-def log_critical(exception: Exception) -> Exception:
-    """
-    Logs a critical error with the exception's message and returns the exception for raising it.
     Does **not** raise the exception, i.e. the command must be preceded by a `raise`.
-
-    Example: `raise log_critical(MyException("My error message"))`
+    Example: `raise log_critical(MyException("My error message"))
 
     Args:
         exception: to extract the error message from
 
     Returns:
-      the given exception
+        the given exception
     """
     log().critical(str(exception))
     return exception
 
 
-def log_error_and_raise(exception: Exception) -> None:
-    """
-    Raises the specified `exception` and logs a critical error with the exception's message
+def log_error(exception: T) -> T:
+    """Logs an error with the exception's message and returns the exception for raising.
 
-    Args:
-        exception: to be raised and logged at level `error`
-
-    Raises:
-        Exception: the given exception
-    """
-    log().error(str(exception))
-    raise exception
-
-
-def log_error(exception: Exception) -> Exception:
-    """
-    Logs an error with the exception's message and returns the exception for raising.
     Does **not** raise the exception, i.e. the command must be preceded by a `raise`.
-
     Example: `raise log_error(MyException("My error message"))`
 
     Args:
         exception: to extract the error message from
 
     Returns:
-      the given exception
+        the given exception
     """
     log().error(str(exception))
     return exception
 
 
-def fameio_logger(log_level_name: str, file_name: Optional[Path] = None) -> None:
+def log_and_print(message: str) -> None:
+    """Logs a message with priority "PRINT"., ensuring it is printed to console.
+
+    Args:
+        message: to be logged with the highest priority
     """
-    Ensures a logger for fameio is present and uses the specified options
+    log().log(LogLevel.PRINT.value, message)
+
+
+def fameio_logger(log_level_name: str, file_name: Path | None = None) -> None:
+    """Ensures a logger for fameio is present and uses the specified options.
 
     Args:
         log_level_name: one of Python's official logging level names, e.g. "INFO"
@@ -128,8 +109,7 @@ def fameio_logger(log_level_name: str, file_name: Optional[Path] = None) -> None
 
 
 def _get_logger(level: LogLevel) -> pylog.Logger:
-    """
-    Returns fameio logger with given log level without any handler and, not propagating to parent
+    """Returns fameio logger with given log level without any handler and, not propagating to parent.
 
     Args:
         level: integer representing the log level
@@ -147,10 +127,11 @@ def _get_logger(level: LogLevel) -> pylog.Logger:
 
 
 def _get_formatter(level: LogLevel) -> pylog.Formatter:
-    """
-    Returns a log formatter depending on the given log `level`
+    """Returns a log formatter depending on the given log `level`.
+
     Args:
         level: this log level determines how detailed the logger's output is
+
     Returns:
         new log formatter
     """
@@ -158,7 +139,7 @@ def _get_formatter(level: LogLevel) -> pylog.Formatter:
 
 
 def _add_handler(logger: pylog.Logger, handler: pylog.Handler, formatter: pylog.Formatter) -> None:
-    """Adds given `handler` using the specified `formatter` to given `logger` and `_handlers` list"""
+    """Adds given `handler` using the specified `formatter` to given `logger` and `_handlers` list."""
     handler.setFormatter(formatter)
     _handlers.append(handler)
     logger.addHandler(handler)

fameio/output/__init__.py

@@ -1,3 +1,7 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: CC0-1.0
+
+
+class OutputError(Exception):
+    """An error that occurred during extracting an output file"""

fameio/output/agent_type.py

@@ -1,13 +1,16 @@
 # SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Union
+from __future__ import annotations
 
 from fameprotobuf.services_pb2 import Output
 
+from fameio.logs import log_error
+from fameio.output import OutputError
+
 
 class AgentType:
-    """Provides information derived from an underlying protobuf AgentType"""
+    """Provides information derived from an underlying protobuf AgentType."""
 
     def __init__(self, agent_type: Output.AgentType) -> None:
         self._agent_type = agent_type
@@ -34,7 +37,7 @@ class AgentType:
         """Returns set of IDs for complex columns, ignoring simple columns"""
         return {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]:
+    def get_column_name_for_id(self, column_index: int) -> 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.fields):
             return self._agent_type.fields[column_index].field_name
@@ -49,44 +52,102 @@ class AgentType:
         return self._agent_type.class_name
 
 
-class AgentTypeError(Exception):
-    """Indicates an error with the agent types definitions"""
+class AgentTypeError(OutputError):
+    """Indicates an error with the agent types definitions."""
 
 
 class AgentTypeLog:
-    """Stores data about collected agent types"""
+    """Stores data about collected agent types."""
 
     _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:
-        self._requested_agents = [agent.upper() for agent in requested_agents] if requested_agents else None
-        self._requested_agent_types = {}
+    def __init__(self, _agent_name_filter_list: list[str]) -> None:
+        """Initialises new AgentTypeLog.
+
+        Args:
+            _agent_name_filter_list: list of agent type names that are requested for output data extraction
+        """
+        self._agent_name_filter_list: list[str] | None = (
+            [agent.upper() for agent in _agent_name_filter_list] if _agent_name_filter_list else None
+        )
+        self._requested_agent_types: dict[str, AgentType] = {}
+        self._agents_with_output: list[str] = []
 
     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:
-                new_types = {
-                    agent_name: agent_type
-                    for agent_name, agent_type in new_types.items()
-                    if agent_name.upper() in self._requested_agents
-                }
-            for agent_name in self._requested_agent_types:
-                if agent_name in new_types:
-                    raise AgentTypeError(self._ERR_DOUBLE_DEFINITION.format(agent_name))
-            self._requested_agent_types.update(new_types)
+        """Saves `new_types` if they are requested for extraction.
+
+        If any new agent types are provided, checks if they are requested for extraction, and, if so, saves them.
+        Agent types not requested for extraction are ignored.
+
+        Args:
+            new_types: to be saved (if requested for extraction)
+
+        Raises:
+            AgentTypeError: if agent type was already registered, logged with level "ERROR"
+        """
+        if not new_types:
+            return
+
+        self._agents_with_output.extend(list(new_types.keys()))
+        filtered_types = self._filter_agents_by_name(new_types)
+        self._ensure_no_duplication(filtered_types)
+        self._requested_agent_types.update(filtered_types)
+
+    def _filter_agents_by_name(self, new_types: dict[str, Output.AgentType]) -> dict[str, Output.AgentType]:
+        """Removes and entries from `new_types` not on `agent_name_filter_list`.
+
+        Args:
+            new_types: to be filtered
+
+        Returns:
+            filtered list, or original list if no filter is active
+        """
+        if self._agent_name_filter_list:
+            return {
+                agent_name: agent_type
+                for agent_name, agent_type in new_types.items()
+                if agent_name.upper() in self._agent_name_filter_list
+            }
+        return new_types
+
+    def _ensure_no_duplication(self, filtered_types: dict[str, Output.AgentType]) -> None:
+        """Ensures no duplicate agent type definitions occur.
+
+        Args:
+            filtered_types: to be checked for duplications with already registered types
+
+        Raises:
+            AgentTypeError: if duplicate agent type is found, logged with level "ERROR"
+        """
+        for agent_name in self._requested_agent_types:
+            if agent_name in filtered_types:
+                raise log_error(AgentTypeError(self._ERR_DOUBLE_DEFINITION.format(agent_name)))
 
     def has_any_agent_type(self) -> bool:
-        """Returns True if any agent type was registered so far present"""
+        """Returns True if any agent type was registered so far present."""
         return len(self._requested_agent_types) > 0
 
-    def get_agent_type(self, agent_name: str) -> AgentType:
-        """Returns `AgentType` of given agent `name`"""
-        if agent_name not in self._requested_agent_types:
-            raise AgentTypeError(self._ERR_AGENT_TYPE_MISSING.format(agent_name))
-        return AgentType(self._requested_agent_types[agent_name])
+    def get_agent_type(self, agent_type_name: str) -> AgentType:
+        """Returns the requested type of agent.
+
+        Args:
+            agent_type_name: requested name of agent type
+
+        Returns:
+            stored agent type
+
+        Raises:
+            AgentTypeError: if no agent type could be found with that name, logged with level "ERROR"
+        """
+        if agent_type_name not in self._requested_agent_types:
+            raise log_error(AgentTypeError(self._ERR_AGENT_TYPE_MISSING.format(agent_type_name)))
+        return AgentType(self._requested_agent_types[agent_type_name])
 
     def is_requested(self, agent_name: str) -> bool:
-        """Returns True if given agent_name is known and requested"""
+        """Returns True if given agent_name is known and requested."""
         return agent_name in self._requested_agent_types
+
+    def get_agents_with_output(self) -> list[str]:
+        """Returns all names of agents that had output."""
+        return self._agents_with_output