fameio 1.8.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

fameio/source/scenario/contract.py

@@ -1,10 +1,11 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-import logging as log
 from typing import Any, Dict, List, Optional
 
+from fameio.source.logs import logger
 from fameio.source.scenario.attribute import Attribute
 from fameio.source.scenario.exception import get_or_default, get_or_raise, log_and_raise
 from fameio.source.time import FameTime
@@ -20,17 +21,18 @@ class Contract:
     _KEY_FIRST_DELIVERY = "FirstDeliveryTime".lower()
     _KEY_INTERVAL = "DeliveryIntervalInSteps".lower()
     _KEY_EXPIRE = "ExpirationTime".lower()
+    _KEY_METADATA = "MetaData".lower()
     _KEY_ATTRIBUTES = "Attributes".lower()
 
-    _MISSING_KEY = "Contract requires key '{}' but is missing it."
-    _MULTI_CONTRACT_CORRUPT = (
+    _ERR_MISSING_KEY = "Contract requires key '{}' but is missing it."
+    _ERR_MULTI_CONTRACT_CORRUPT = (
         "Definition of Contracts is valid only for One-to-One, One-to-many, Many-to-one, "
         "or N-to-N sender-to-receiver numbers. Found M-to-N pairing in Contract with "
         "Senders: {} and Receivers: {}."
     )
-    _NEGATIVE_INTERVAL = "Contract delivery interval must be a positive integer but was: {}"
-    _SENDER_IS_RECEIVER = "Contract sender and receiver have the same id: {}"
-    _DOUBLE_ATTRIBUTE = "Cannot add attribute '{}' to contract because it already exists."
+    _ERR_INTERVAL_NOT_POSITIVE = "Contract delivery interval must be a positive integer but was: {}"
+    _ERR_SENDER_IS_RECEIVER = "Contract sender and receiver have the same id: {}"
+    _ERR_DOUBLE_ATTRIBUTE = "Cannot add attribute '{}' to contract because it already exists."
 
     def __init__(
         self,
@@ -40,19 +42,21 @@ class Contract:
         delivery_interval: int,
         first_delivery_time: int,
         expiration_time: Optional[int] = None,
-    ):
+        meta_data: Optional[dict] = None,
+    ) -> None:
         """Constructs a new Contract"""
         assert product_name != ""
         if sender_id == receiver_id:
-            log.warning(self._SENDER_IS_RECEIVER.format(sender_id))
-        if delivery_interval < 0:
-            raise ValueError(self._NEGATIVE_INTERVAL.format(delivery_interval))
+            logger().warning(self._ERR_SENDER_IS_RECEIVER.format(sender_id))
+        if delivery_interval <= 0:
+            raise ValueError(self._ERR_INTERVAL_NOT_POSITIVE.format(delivery_interval))
         self._sender_id = sender_id
         self._receiver_id = receiver_id
         self._product_name = product_name
         self._delivery_interval = delivery_interval
         self._first_delivery_time = first_delivery_time
         self._expiration_time = expiration_time
+        self._meta_data = meta_data
         self._attributes = {}
 
     def _notify_data_changed(self):
@@ -99,39 +103,37 @@ class Contract:
         """Returns the expiration time of the contract if available, None otherwise"""
         return self._expiration_time
 
+    @property
+    def meta_data(self) -> Optional[dict]:
+        """Returns the metadata of the contract if available, None otherwise"""
+        return self._meta_data
+
     @property
     def attributes(self) -> Dict[str, Attribute]:
         """Returns dictionary of all Attributes of the contract"""
         return self._attributes
 
-    def add_attribute(self, name: str, value: Attribute):
+    def add_attribute(self, name: str, value: Attribute) -> None:
         """Adds a new attribute to the Contract (raise an error if it already exists)"""
         if name in self._attributes:
-            raise ValueError(self._DOUBLE_ATTRIBUTE.format(name))
+            raise ValueError(self._ERR_DOUBLE_ATTRIBUTE.format(name))
         self._attributes[name] = value
         self._notify_data_changed()
 
-    def __init_attributes_from_dict(self, attributes: Dict[str, Any]) -> None:
-        """Resets Contract `attributes` from dict; Must only be called when creating a new Contract"""
-        assert len(self._attributes) == 0
-        self._attributes = {}
-        for name, value in attributes.items():
-            full_name = str(type) + "." + str(id) + name
-            self.add_attribute(name, Attribute(full_name, value))
-
     @classmethod
-    def from_dict(cls, definitions: dict) -> "Contract":
+    def from_dict(cls, definitions: dict) -> Contract:
         """Parses Contract from given `definitions`"""
         definitions = keys_to_lower(definitions)
-        sender_id = get_or_raise(definitions, Contract._KEY_SENDER, Contract._MISSING_KEY)
-        receiver_id = get_or_raise(definitions, Contract._KEY_RECEIVER, Contract._MISSING_KEY)
-        product_name = get_or_raise(definitions, Contract._KEY_PRODUCT, Contract._MISSING_KEY)
+        sender_id = get_or_raise(definitions, Contract._KEY_SENDER, Contract._ERR_MISSING_KEY)
+        receiver_id = get_or_raise(definitions, Contract._KEY_RECEIVER, Contract._ERR_MISSING_KEY)
+        product_name = get_or_raise(definitions, Contract._KEY_PRODUCT, Contract._ERR_MISSING_KEY)
         first_delivery_time = FameTime.convert_string_if_is_datetime(
-            get_or_raise(definitions, Contract._KEY_FIRST_DELIVERY, Contract._MISSING_KEY)
+            get_or_raise(definitions, Contract._KEY_FIRST_DELIVERY, Contract._ERR_MISSING_KEY)
         )
-        delivery_interval = get_or_raise(definitions, Contract._KEY_INTERVAL, Contract._MISSING_KEY)
+        delivery_interval = get_or_raise(definitions, Contract._KEY_INTERVAL, Contract._ERR_MISSING_KEY)
         expiration_time = get_or_default(definitions, Contract._KEY_EXPIRE, None)
         expiration_time = FameTime.convert_string_if_is_datetime(expiration_time) if expiration_time else None
+        meta_data = get_or_default(definitions, Contract._KEY_METADATA, None)
         result = cls(
             sender_id,
             receiver_id,
@@ -139,19 +141,29 @@ class Contract:
             delivery_interval,
             first_delivery_time,
             expiration_time,
+            meta_data,
         )
         attribute_definitions = get_or_default(definitions, Contract._KEY_ATTRIBUTES, dict())
-        result.__init_attributes_from_dict(attribute_definitions)
+        result._init_attributes_from_dict(attribute_definitions)
         return result
 
+    def _init_attributes_from_dict(self, attributes: Dict[str, Any]) -> None:
+        """Resets Contract `attributes` from dict; Must only be called when creating a new Contract"""
+        assert len(self._attributes) == 0
+        self._attributes = {}
+        for name, value in attributes.items():
+            full_name = f"{type}.{id}{name}"
+            self.add_attribute(name, Attribute(full_name, value))
+
     def to_dict(self) -> dict:
         """Serializes the Contract content to a dict"""
-        result = {}
-        result[self._KEY_SENDER] = self.sender_id
-        result[self._KEY_RECEIVER] = self.receiver_id
-        result[self._KEY_PRODUCT] = self.product_name
-        result[self._KEY_FIRST_DELIVERY] = self.first_delivery_time
-        result[self._KEY_INTERVAL] = self.delivery_interval
+        result = {
+            self._KEY_SENDER: self.sender_id,
+            self._KEY_RECEIVER: self.receiver_id,
+            self._KEY_PRODUCT: self.product_name,
+            self._KEY_FIRST_DELIVERY: self.first_delivery_time,
+            self._KEY_INTERVAL: self.delivery_interval,
+        }
 
         if self.expiration_time is not None:
             result[self._KEY_EXPIRE] = self.expiration_time
@@ -161,6 +173,8 @@ class Contract:
             for attr_name, attr_value in self.attributes.items():
                 attributes_dict[attr_name] = attr_value.generic_content
             result[self._KEY_ATTRIBUTES] = attributes_dict
+        if self.meta_data:
+            result[self._KEY_METADATA] = self._meta_data
 
         return result
 
@@ -173,15 +187,15 @@ class Contract:
         for key in [
             Contract._KEY_PRODUCT,
             Contract._KEY_FIRST_DELIVERY,
-            Contract._KEY_FIRST_DELIVERY,
             Contract._KEY_INTERVAL,
             Contract._KEY_EXPIRE,
+            Contract._KEY_METADATA,
             Contract._KEY_ATTRIBUTES,
         ]:
             if key in multi_definition:
                 base_data[key] = multi_definition[key]
-        senders = ensure_is_list(get_or_raise(multi_definition, Contract._KEY_SENDER, Contract._MISSING_KEY))
-        receivers = ensure_is_list(get_or_raise(multi_definition, Contract._KEY_RECEIVER, Contract._MISSING_KEY))
+        senders = ensure_is_list(get_or_raise(multi_definition, Contract._KEY_SENDER, Contract._ERR_MISSING_KEY))
+        receivers = ensure_is_list(get_or_raise(multi_definition, Contract._KEY_RECEIVER, Contract._ERR_MISSING_KEY))
         if len(senders) > 1 and len(receivers) == 1:
             for index in range(len(senders)):
                 contracts.append(Contract._copy_contract(senders[index], receivers[0], base_data))
@@ -192,14 +206,15 @@ class Contract:
             for index in range(len(senders)):
                 contracts.append(Contract._copy_contract(senders[index], receivers[index], base_data))
         else:
-            log_and_raise(Contract._MULTI_CONTRACT_CORRUPT.format(senders, receivers))
+            log_and_raise(Contract._ERR_MULTI_CONTRACT_CORRUPT.format(senders, receivers))
         return contracts
 
     @staticmethod
     def _copy_contract(sender: int, receiver: int, base_data: dict) -> dict:
         """Returns a new contract definition dictionary, with given `sender` and `receiver` and copied `base_data`"""
-        contract = {}
-        contract[Contract._KEY_SENDER] = sender
-        contract[Contract._KEY_RECEIVER] = receiver
+        contract = {
+            Contract._KEY_SENDER: sender,
+            Contract._KEY_RECEIVER: receiver,
+        }
         contract.update(base_data)
         return contract

fameio/source/scenario/exception.py

@@ -2,17 +2,19 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import logging as log
+from typing import NoReturn, Any, Union
 
-from fameio.source.logs import log_error_and_raise
+from fameio.source.logs import log_error_and_raise, logger
 
+_DEFAULT_USED = "Using default value '{}' for missing key '{}'"
 
-def log_and_raise(message: str):
+
+def log_and_raise(message: str) -> NoReturn:
     """Raises ScenarioException with given `message`"""
     log_error_and_raise(ScenarioException(message))
 
 
-def get_or_raise(dictionary: dict, key: str, message: str):
+def get_or_raise(dictionary: dict, key: str, message: str) -> Union[Any, NoReturn]:
     """Returns value associated with `key` in given `dictionary`, or raises ScenarioException if key is missing"""
     if key not in dictionary or dictionary[key] is None:
         log_error_and_raise(ScenarioException(message.format(key)))
@@ -20,18 +22,18 @@ def get_or_raise(dictionary: dict, key: str, message: str):
         return dictionary[key]
 
 
-def assert_or_raise(assertion: bool, message: str):
-    """Raises ScenarioException with given `message` if `assertion` is `False`"""
+def assert_or_raise(assertion: bool, msg: str) -> None:
+    """Raises new ScenarioException with given `msg` if `assertion` is False"""
     if not assertion:
-        log_error_and_raise(ScenarioException(message))
+        log_error_and_raise(ScenarioException(msg))
 
 
-def get_or_default(dictionary: dict, key: str, default_value):
+def get_or_default(dictionary: dict, key: str, default_value) -> Any:
     """Returns value associated with `key` in given `dictionary`, or the given `default_value` if key is missing"""
     if key in dictionary and dictionary[key] is not None:
         return dictionary[key]
     else:
-        log.debug("Using default value '{}' for missing key '{}'".format(default_value, key))
+        logger().debug(_DEFAULT_USED.format(default_value, key))
         return default_value
 
 

fameio/source/scenario/generalproperties.py

@@ -1,9 +1,9 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-import logging as log
-
+from fameio.source.logs import logger
 from fameio.source.scenario.exception import get_or_default, get_or_raise
 from fameio.source.time import FameTime
 from fameio.source.tools import keys_to_lower
@@ -34,7 +34,7 @@ class GeneralProperties:
         output_process: int,
     ) -> None:
         if simulation_stop_time < simulation_start_time:
-            log.warning(GeneralProperties._SIMULATION_DURATION)
+            logger().warning(GeneralProperties._SIMULATION_DURATION)
         self._run_id = run_id
         self._simulation_start_time = simulation_start_time
         self._simulation_stop_time = simulation_stop_time
@@ -43,7 +43,7 @@ class GeneralProperties:
         self._output_process = output_process
 
     @classmethod
-    def from_dict(cls, definitions: dict) -> "GeneralProperties":
+    def from_dict(cls, definitions: dict) -> GeneralProperties:
         """Parse general properties from provided `definitions`"""
         definitions = keys_to_lower(definitions)
         run_id = get_or_default(definitions, GeneralProperties._KEY_RUN, 1)
@@ -79,21 +79,15 @@ class GeneralProperties:
 
     def to_dict(self) -> dict:
         """Serializes the general properties to a dict"""
-        result = {}
-
-        result[self._KEY_RUN] = self.run_id
-
-        simulation_dict = {}
-        simulation_dict[self._KEY_START] = self.simulation_start_time
-        simulation_dict[self._KEY_STOP] = self.simulation_stop_time
-        simulation_dict[self._KEY_SEED] = self.simulation_random_seed
+        result = {self._KEY_RUN: self._run_id}
+        simulation_dict = {
+            self._KEY_START: self.simulation_start_time,
+            self._KEY_STOP: self.simulation_stop_time,
+            self._KEY_SEED: self.simulation_random_seed,
+        }
         result[self._KEY_SIMULATION] = simulation_dict
-
-        output_dict = {}
-        output_dict[self._KEY_INTERVAL] = self.output_interval
-        output_dict[self._KEY_PROCESS] = self.output_process
+        output_dict = {self._KEY_INTERVAL: self.output_interval, self._KEY_PROCESS: self.output_process}
         result[self._KEY_OUTPUT] = output_dict
-
         return result
 
     @property

fameio/source/scenario/scenario.py

@@ -1,6 +1,7 @@
-# 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 __future__ import annotations
 
 from typing import List
 
@@ -30,7 +31,7 @@ class Scenario:
         self._contracts = []
 
     @classmethod
-    def from_dict(cls, definitions: dict, factory=FameIOFactory()) -> "Scenario":
+    def from_dict(cls, definitions: dict, factory=FameIOFactory()) -> Scenario:
         """Parse scenario from provided `definitions` using given `factory`"""
         definitions = keys_to_lower(definitions)
 
@@ -38,29 +39,33 @@ class Scenario:
         general_props = factory.new_general_properties_from_dict(
             get_or_raise(definitions, Scenario._KEY_GENERAL, Scenario._MISSING_KEY)
         )
-        result = cls(schema, general_props)
+        scenario = cls(schema, general_props)
 
         for agent_definition in get_or_default(definitions, Scenario._KEY_AGENTS, []):
-            result.add_agent(factory.new_agent_from_dict(agent_definition))
+            scenario.add_agent(factory.new_agent_from_dict(agent_definition))
 
-        for multi_definition in get_or_default(definitions, Scenario._KEY_CONTRACTS, []):
-            for single_contract_definition in Contract.split_contract_definitions(multi_definition):
-                result.add_contract(factory.new_contract_from_dict(single_contract_definition))
+        for multi_contract_definition in get_or_default(definitions, Scenario._KEY_CONTRACTS, []):
+            for single_contract_definition in Contract.split_contract_definitions(multi_contract_definition):
+                scenario.add_contract(factory.new_contract_from_dict(single_contract_definition))
 
-        return result
+        return scenario
 
     def to_dict(self) -> dict:
         """Serializes the scenario content to a dict"""
         result = {
             Scenario._KEY_GENERAL: self.general_properties.to_dict(),
             Scenario._KEY_SCHEMA: self.schema.to_dict(),
-            Scenario._KEY_AGENTS: [],
         }
-        for agent in self.agents:
-            result[Scenario._KEY_AGENTS].append(agent.to_dict())
-        result[Scenario._KEY_CONTRACTS] = []
-        for contract in self.contracts:
-            result[Scenario._KEY_CONTRACTS].append(contract.to_dict())
+
+        if self.agents:
+            result[Scenario._KEY_AGENTS] = []
+            for agent in self.agents:
+                result[Scenario._KEY_AGENTS].append(agent.to_dict())
+
+        if self.contracts:
+            result[Scenario._KEY_CONTRACTS] = []
+            for contract in self.contracts:
+                result[Scenario._KEY_CONTRACTS].append(contract.to_dict())
         return result
 
     @property

fameio/source/schema/agenttype.py

@@ -1,11 +1,11 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-import logging as log
 from typing import Dict, List, Any
 
-from fameio.source.logs import log_error_and_raise
+from fameio.source.logs import log_error_and_raise, logger
 from fameio.source.schema.exception import SchemaException
 from fameio.source.schema.attribute import AttributeSpecs
 from fameio.source.tools import keys_to_lower
@@ -14,59 +14,93 @@ from fameio.source.tools import keys_to_lower
 class AgentType:
     """Schema definitions for an Agent type"""
 
-    _ERR_PRODUCTS_NO_STRING_LIST = "Product definition of AgentType '{}' contains item(s) other than string: '{}'"
+    _ERR_NAME_INVALID = "'{}' is not a valid name for AgentTypes"
+    _ERR_PRODUCTS_NO_STRING = "Product definition of AgentType '{}' contains item(s) / key(s) other than string: '{}'"
     _ERR_PRODUCTS_UNKNOWN_STRUCTURE = "Product definition of AgentType '{}' is neither list nor dictionary: '{}'"
 
     _NO_ATTRIBUTES = "Agent '{}' has no specified 'Attributes'."
     _NO_PRODUCTS = "Agent '{}' has no specified 'Products'."
+    _NO_OUTPUTS = "Agent '{}' has no specified 'Outputs'."
+    _NO_METADATA = "Agent '{}' has no specified 'Metadata'."
 
     _KEY_ATTRIBUTES = "Attributes".lower()
     _KEY_PRODUCTS = "Products".lower()
+    _KEY_OUTPUTS = "Outputs".lower()
+    _KEY_METADATA = "MetaData".lower()
 
     def __init__(self, name: str):
+        """
+        Initialise a new AgentType
+
+        Args:
+            name: name of the AgenType - must not be None or empty
+        """
+        if not name or name.isspace():
+            log_error_and_raise(SchemaException(AgentType._ERR_NAME_INVALID.format(name)))
         self._name = name
         self._attributes = {}
-        self._products = []
+        self._products = {}
+        self._outputs = {}
+        self._metadata = {}
 
     @classmethod
-    def from_dict(cls, name: str, definitions: dict) -> "AgentType":
-        """Loads an agent type `definition` from the given input dict"""
-        definition = keys_to_lower(definitions)
+    def from_dict(cls, name: str, definitions: dict) -> AgentType:
+        """
+        Creates AgentType with given `name` from specified dictionary
+
+        Args:
+            name: of the agent type
+            definitions: of the agent type specifying, e.g., its attributes and products
 
-        result = cls(name)
+        Returns:
+            a new instance of AgentType
+        """
+        agent_type = cls(name)
+
+        definition = keys_to_lower(definitions)
         if AgentType._KEY_ATTRIBUTES in definition:
             for attribute_name, attribute_details in definition[AgentType._KEY_ATTRIBUTES].items():
                 full_name = name + "." + attribute_name
-                result._attributes[attribute_name] = AttributeSpecs(full_name, attribute_details)
+                agent_type._attributes[attribute_name] = AttributeSpecs(full_name, attribute_details)
+        else:
+            logger().info(AgentType._NO_ATTRIBUTES.format(name))
+
+        if AgentType._KEY_PRODUCTS in definition and definition[AgentType._KEY_PRODUCTS]:
+            agent_type._products.update(AgentType._read_products(definition[AgentType._KEY_PRODUCTS], name))
+        else:
+            logger().info(AgentType._NO_PRODUCTS.format(name))
+
+        if AgentType._KEY_OUTPUTS in definition:
+            outputs_to_add = definition[AgentType._KEY_OUTPUTS]
+            if outputs_to_add:
+                agent_type._outputs.update(outputs_to_add)
         else:
-            log.info(AgentType._NO_ATTRIBUTES.format(name))
+            logger().debug(AgentType._NO_OUTPUTS.format(name))
 
-        if AgentType._KEY_PRODUCTS in definition:
-            products_to_add = definition[AgentType._KEY_PRODUCTS]
-            if products_to_add:
-                result._products.extend(AgentType.read_products(products_to_add, name))
+        if AgentType._KEY_METADATA in definition:
+            metadata_to_add = definition[AgentType._KEY_METADATA]
+            if metadata_to_add:
+                agent_type._metadata.update(metadata_to_add)
+        else:
+            logger().debug(AgentType._NO_METADATA.format(name))
 
-        if not result._products:
-            log.info(AgentType._NO_PRODUCTS.format(name))
-        return result
+        return agent_type
 
     @staticmethod
-    def read_products(products: Any, agent_type: str) -> List[str]:
-        """Returns a list of product names obtained from given `products` defined for `agent_type`"""
+    def _read_products(products: Any, agent_type: str) -> Dict[str, Any]:
+        """Returns a dict obtained from given `products` defined for `agent_type`"""
         product_names = None
         if isinstance(products, dict):
-            product_names = [key for key in products.keys()]
-        elif isinstance(products, list):
             product_names = products
+        elif isinstance(products, list):
+            product_names = {key: None for key in products}
         else:
             log_error_and_raise(SchemaException(AgentType._ERR_PRODUCTS_UNKNOWN_STRUCTURE.format(agent_type, products)))
 
-        if all([isinstance(item, str) for item in product_names]):
+        if all([isinstance(item, str) for item in product_names.keys()]):
             return product_names
         else:
-            log_error_and_raise(
-                SchemaException(AgentType._ERR_PRODUCTS_NO_STRING_LIST.format(agent_type, product_names))
-            )
+            log_error_and_raise(SchemaException(AgentType._ERR_PRODUCTS_NO_STRING.format(agent_type, product_names)))
 
     @property
     def name(self) -> str:
@@ -74,11 +108,25 @@ class AgentType:
         return self._name
 
     @property
-    def products(self) -> list:
-        """Returns list of products or an empty list if no products are defined"""
+    def products(self) -> dict:
+        """Returns dict of products or an empty dict if no products are defined"""
         return self._products
 
+    def get_product_names(self) -> List[str]:
+        """Returns list of product names or an empty list if no products are defined"""
+        return list(self._products.keys())
+
     @property
     def attributes(self) -> Dict[str, AttributeSpecs]:
         """Returns list of Attributes of this agent or an empty list if no attributes are defined"""
         return self._attributes
+
+    @property
+    def outputs(self) -> dict:
+        """Returns list of outputs or an empty list if no outputs are defined"""
+        return self._outputs
+
+    @property
+    def metadata(self) -> dict:
+        """Returns list of metadata or an empty list if no metadata are defined"""
+        return self._metadata

fameio/source/schema/attribute.py

@@ -1,12 +1,13 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-import logging as log
 import typing
 from enum import Enum, auto
 from typing import Any, Dict
 
+from fameio.source.logs import logger
 from fameio.source.schema.exception import SchemaException
 from fameio.source.time import FameTime
 from fameio.source.tools import keys_to_lower
@@ -49,7 +50,7 @@ class AttributeSpecs:
     _DEFAULT_NOT_LIST = "Attribute is list, but provided Default '{}' is not a list."
     _DEFAULT_INCOMPATIBLE = "Default '{}' can not be converted to AttributeType '{}'."
     _DEFAULT_DISALLOWED = "Default '{}' is not an allowed value."
-    _LIST_DISALLOWED = "Attribute '{}' of type TIME_SERIES cannot be list."
+    _LIST_DISALLOWED = "Attribute '{}' of type TIME_SERIES cannot be a list."
     _VALUES_ILL_FORMAT = "Only List and Dictionary is supported for 'Values' but was: {}"
 
     _KEY_MANDATORY = "Mandatory".lower()
@@ -69,18 +70,18 @@ class AttributeSpecs:
             self._is_mandatory = definition[AttributeSpecs._KEY_MANDATORY]
         else:
             self._is_mandatory = True
-            log.warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_MANDATORY, name, True))
+            logger().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_MANDATORY, name, True))
 
         if AttributeSpecs._KEY_LIST in definition:
             self._is_list = definition[AttributeSpecs._KEY_LIST]
         else:
             self._is_list = False
-            log.warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_LIST, name, False))
+            logger().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_LIST, name, False))
 
         if AttributeSpecs._KEY_TYPE in definition:
             self._attr_type = AttributeSpecs._get_type_for_name(definition[AttributeSpecs._KEY_TYPE])
         else:
-            log.error(AttributeSpecs._MISSING_TYPE.format(name))
+            logger().error(AttributeSpecs._MISSING_TYPE.format(name))
             raise SchemaException(AttributeSpecs._MISSING_TYPE.format(name))
 
         if self._attr_type == AttributeType.TIME_SERIES and self._is_list:
@@ -183,7 +184,7 @@ class AttributeSpecs:
         return self._full_name
 
     @staticmethod
-    def _get_type_for_name(name: str) -> "AttributeType":
+    def _get_type_for_name(name: str) -> AttributeType:
         """Returns the AttributeType matching the given `name` converted to upper case"""
         try:
             return AttributeType[name.upper()]
@@ -197,5 +198,5 @@ class AttributeSpecs:
 
     @property
     def help_text(self) -> str:
-        """Return the help_text of this attribute, if any"""
+        """Return the help_text of this attribute, if any, otherwise an empty string"""
         return self._help if self.has_help_text else ""

fameio/source/schema/schema.py

@@ -1,7 +1,9 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
+import ast
 from typing import Dict
 
 from fameio.source.logs import log_error_and_raise
@@ -13,32 +15,43 @@ from fameio.source.tools import keys_to_lower
 class Schema:
     """Definition of a schema"""
 
-    _AGENT_TYPES_MISSING = "Keyword AgentTypes not found in Schema."
+    _AGENT_TYPES_MISSING = "Required keyword `AgentTypes` missing in Schema."
+    _AGENT_TYPES_EMPTY = "`AgentTypes` must not be empty - at least one type of agent is required."
     _KEY_AGENT_TYPE = "AgentTypes".lower()
 
     def __init__(self, definitions: dict):
-        # the current Schema class design is read-only, so it's much simpler to remember the original schema dict
-        # in order to implement to_dict()
         self._original_input_dict = definitions
-
-        # fill the agent types
         self._agent_types = {}
-        for agent_type_name, agent_definition in definitions[Schema._KEY_AGENT_TYPE].items():
-            agent_type = AgentType.from_dict(agent_type_name, agent_definition)
-            self._agent_types[agent_type_name] = agent_type
 
     @classmethod
-    def from_dict(cls, definitions: dict) -> "Schema":
-        """Load definitions from given `schema`"""
+    def from_dict(cls, definitions: dict) -> Schema:
+        """Load given dictionary `definitions` into a new Schema"""
         definitions = keys_to_lower(definitions)
         if Schema._KEY_AGENT_TYPE not in definitions:
             log_error_and_raise(SchemaException(Schema._AGENT_TYPES_MISSING))
-        return cls(definitions)
+        schema = cls(definitions)
+        agent_types = definitions[Schema._KEY_AGENT_TYPE]
+        if len(agent_types) == 0:
+            log_error_and_raise(SchemaException(Schema._AGENT_TYPES_EMPTY))
+
+        for agent_type_name, agent_definition in agent_types.items():
+            agent_type = AgentType.from_dict(agent_type_name, agent_definition)
+            schema._agent_types[agent_type_name] = agent_type
+        return schema
+
+    @classmethod
+    def from_string(cls, definitions: str) -> Schema:
+        """Load given string `definitions` into a new Schema"""
+        return cls.from_dict(ast.literal_eval(definitions))
 
     def to_dict(self) -> dict:
         """Serializes the schema content to a dict"""
         return self._original_input_dict
 
+    def to_string(self) -> str:
+        """Returns a string representation of the Schema of which the class can be rebuilt"""
+        return repr(self.to_dict())
+
     @property
     def agent_types(self) -> Dict[str, AgentType]:
         """Returns all the agent types by their name"""