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

fameio/{source → input}/scenario/contract.py

@@ -3,26 +3,26 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional, Final
 
-from fameio.source.logs import log
-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
-from fameio.source.tools import ensure_is_list, keys_to_lower
+from fameio.input.metadata import Metadata
+from fameio.logs import log
+from fameio.time import FameTime
+from fameio.tools import ensure_is_list, keys_to_lower
+from .attribute import Attribute
+from .exception import get_or_default, get_or_raise, log_and_raise
 
 
-class Contract:
+class Contract(Metadata):
     """Contract between two Agents of a scenario"""
 
-    _KEY_SENDER = "SenderId".lower()
-    _KEY_RECEIVER = "ReceiverId".lower()
-    _KEY_PRODUCT = "ProductName".lower()
-    _KEY_FIRST_DELIVERY = "FirstDeliveryTime".lower()
-    _KEY_INTERVAL = "DeliveryIntervalInSteps".lower()
-    _KEY_EXPIRE = "ExpirationTime".lower()
-    _KEY_METADATA = "MetaData".lower()
-    _KEY_ATTRIBUTES = "Attributes".lower()
+    KEY_SENDER: Final[str] = "SenderId".lower()
+    KEY_RECEIVER: Final[str] = "ReceiverId".lower()
+    KEY_PRODUCT: Final[str] = "ProductName".lower()
+    KEY_FIRST_DELIVERY: Final[str] = "FirstDeliveryTime".lower()
+    KEY_INTERVAL: Final[str] = "DeliveryIntervalInSteps".lower()
+    KEY_EXPIRE: Final[str] = "ExpirationTime".lower()
+    KEY_ATTRIBUTES: Final[str] = "Attributes".lower()
 
     _ERR_MISSING_KEY = "Contract requires key '{}' but is missing it."
     _ERR_MULTI_CONTRACT_CORRUPT = (
@@ -42,9 +42,10 @@ class Contract:
         delivery_interval: int,
         first_delivery_time: int,
         expiration_time: Optional[int] = None,
-        meta_data: Optional[dict] = None,
+        metadata: Optional[dict] = None,
     ) -> None:
         """Constructs a new Contract"""
+        super().__init__({self.KEY_METADATA: metadata} if metadata else None)
         assert product_name != ""
         if sender_id == receiver_id:
             log().warning(self._ERR_SENDER_IS_RECEIVER.format(sender_id))
@@ -56,7 +57,6 @@ class Contract:
         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):
@@ -104,12 +104,7 @@ class Contract:
         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]:
+    def attributes(self) -> dict[str, Attribute]:
         """Returns dictionary of all Attributes of the contract"""
         return self._attributes
 
@@ -124,30 +119,30 @@ class 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._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)
+        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._ERR_MISSING_KEY)
+            get_or_raise(definitions, Contract.KEY_FIRST_DELIVERY, Contract._ERR_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)
+        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(
+
+        contract = cls(
             sender_id,
             receiver_id,
             product_name,
             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)
-        return result
+        contract._extract_metadata(definitions)
+        attribute_definitions = get_or_default(definitions, Contract.KEY_ATTRIBUTES, {})
+        contract._init_attributes_from_dict(attribute_definitions)
+        return contract
 
-    def _init_attributes_from_dict(self, attributes: Dict[str, Any]) -> None:
+    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 = {}
@@ -155,47 +150,41 @@ class Contract:
             full_name = f"{type}.{id}{name}"
             self.add_attribute(name, Attribute(full_name, value))
 
-    def to_dict(self) -> dict:
+    def _to_dict(self) -> dict:
         """Serializes the Contract content to a dict"""
         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,
+            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
+            result[self.KEY_EXPIRE] = self.expiration_time
 
         if len(self.attributes) > 0:
-            attributes_dict = {}
-            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
-
+            result[self.KEY_ATTRIBUTES] = {name: value.to_dict() for name, value in self.attributes.items()}
         return result
 
     @staticmethod
-    def split_contract_definitions(multi_definition: dict) -> List[dict]:
+    def split_contract_definitions(multi_definition: dict) -> list[dict]:
         """Splits given `multi_definition` dictionary into list of individual Contract definitions"""
         contracts = []
         base_data = {}
         multi_definition = keys_to_lower(multi_definition)
         for key in [
-            Contract._KEY_PRODUCT,
-            Contract._KEY_FIRST_DELIVERY,
-            Contract._KEY_INTERVAL,
-            Contract._KEY_EXPIRE,
-            Contract._KEY_METADATA,
-            Contract._KEY_ATTRIBUTES,
+            Contract.KEY_PRODUCT,
+            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._ERR_MISSING_KEY))
-        receivers = ensure_is_list(get_or_raise(multi_definition, Contract._KEY_RECEIVER, Contract._ERR_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))
@@ -213,8 +202,8 @@ class Contract:
     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._KEY_SENDER: sender,
-            Contract._KEY_RECEIVER: receiver,
+            Contract.KEY_SENDER: sender,
+            Contract.KEY_RECEIVER: receiver,
         }
         contract.update(base_data)
         return contract

fameio/{source → input}/scenario/exception.py

@@ -1,31 +1,32 @@
-# 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 NoReturn, Any, Union
 
-from fameio.source.logs import log_error_and_raise, log
+from fameio.input import ScenarioError
+from fameio.logs import log_error_and_raise, log
 
 _DEFAULT_USED = "Using default value '{}' for missing key '{}'"
 
 
 def log_and_raise(message: str) -> NoReturn:
-    """Raises ScenarioException with given `message`"""
-    log_error_and_raise(ScenarioException(message))
+    """Raises ScenarioError with given `message`"""
+    log_error_and_raise(ScenarioError(message))
 
 
 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)))
+        log_error_and_raise(ScenarioError(message.format(key)))
     else:
         return dictionary[key]
 
 
 def assert_or_raise(assertion: bool, msg: str) -> None:
-    """Raises new ScenarioException with given `msg` if `assertion` is False"""
+    """Raises new ScenarioError with given `msg` if `assertion` is False"""
     if not assertion:
-        log_error_and_raise(ScenarioException(msg))
+        log_error_and_raise(ScenarioError(msg))
 
 
 def get_or_default(dictionary: dict, key: str, default_value) -> Any:
@@ -35,9 +36,3 @@ def get_or_default(dictionary: dict, key: str, default_value) -> Any:
     else:
         log().debug(_DEFAULT_USED.format(default_value, key))
         return default_value
-
-
-class ScenarioException(Exception):
-    """Indicates an error while parsing a scenario or one of its components"""
-
-    pass

fameio/{source → input}/scenario/fameiofactory.py

@@ -1,11 +1,11 @@
-# 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 fameio.source.scenario.stringset import StringSet
-from fameio.source.schema.schema import Schema
-from fameio.source.scenario.generalproperties import GeneralProperties
-from fameio.source.scenario.agent import Agent
-from fameio.source.scenario.contract import Contract
+from fameio.input.schema import Schema
+from .agent import Agent
+from .contract import Contract
+from .generalproperties import GeneralProperties
+from .stringset import StringSet
 
 
 class FameIOFactory:

fameio/{source → input}/scenario/generalproperties.py

@@ -3,27 +3,25 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from fameio.source.logs import log
-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
+from typing import Final
+
+from fameio.logs import log
+from fameio.time import FameTime
+from fameio.tools import keys_to_lower
+from .exception import get_or_default, get_or_raise
 
 
 class GeneralProperties:
     """Hosts general properties of a scenario"""
 
-    _KEY_RUN = "RunId".lower()
-    _KEY_SIMULATION = "Simulation".lower()
-    _KEY_START = "StartTime".lower()
-    _KEY_STOP = "StopTime".lower()
-    _KEY_SEED = "RandomSeed".lower()
-    _KEY_OUTPUT = "Output".lower()
-    _KEY_INTERVAL = "Interval".lower()
-    _KEY_PROCESS = "Process".lower()
+    KEY_RUN: Final[str] = "RunId".lower()
+    KEY_SIMULATION = "Simulation".lower()
+    KEY_START = "StartTime".lower()
+    KEY_STOP = "StopTime".lower()
+    KEY_SEED = "RandomSeed".lower()
 
     _ERR_MISSING_KEY = "General Properties requires key '{}' but it is missing."
     _ERR_SIMULATION_DURATION = "Simulation starts after its end time - check start and stop times."
-    _WARN_OUTPUT_DEPRECATED = "Deprecation warning: GeneralProperties.Output will be removed with FAME-Io version > 3.0"
 
     def __init__(
         self,
@@ -31,8 +29,6 @@ class GeneralProperties:
         simulation_start_time: int,
         simulation_stop_time: int,
         simulation_random_seed: int,
-        output_interval: int,
-        output_process: int,
     ) -> None:
         if simulation_stop_time < simulation_start_time:
             log().warning(GeneralProperties._ERR_SIMULATION_DURATION)
@@ -40,57 +36,46 @@ class GeneralProperties:
         self._simulation_start_time = simulation_start_time
         self._simulation_stop_time = simulation_stop_time
         self._simulation_random_seed = simulation_random_seed
-        self._output_interval = output_interval
-        self._output_process = output_process
 
     @classmethod
     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)
+        run_id = get_or_default(definitions, GeneralProperties.KEY_RUN, 1)
 
         simulation_definition = keys_to_lower(
             get_or_raise(
                 definitions,
-                GeneralProperties._KEY_SIMULATION,
+                GeneralProperties.KEY_SIMULATION,
                 GeneralProperties._ERR_MISSING_KEY,
             )
         )
         start_time = FameTime.convert_string_if_is_datetime(
             get_or_raise(
                 simulation_definition,
-                GeneralProperties._KEY_START,
+                GeneralProperties.KEY_START,
                 GeneralProperties._ERR_MISSING_KEY,
             )
         )
         stop_time = FameTime.convert_string_if_is_datetime(
             get_or_raise(
                 simulation_definition,
-                GeneralProperties._KEY_STOP,
+                GeneralProperties.KEY_STOP,
                 GeneralProperties._ERR_MISSING_KEY,
             )
         )
-        random_seed = get_or_default(simulation_definition, GeneralProperties._KEY_SEED, 1)
-
-        output_definitions = keys_to_lower(get_or_default(definitions, GeneralProperties._KEY_OUTPUT, dict()))
-        if len(output_definitions) > 1:
-            log().warning(GeneralProperties._WARN_OUTPUT_DEPRECATED)
-        output_interval = get_or_default(output_definitions, GeneralProperties._KEY_INTERVAL, 100)
-        output_process = get_or_default(output_definitions, GeneralProperties._KEY_PROCESS, 0)
-
-        return cls(run_id, start_time, stop_time, random_seed, output_interval, output_process)
+        random_seed = get_or_default(simulation_definition, GeneralProperties.KEY_SEED, 1)
+        return cls(run_id, start_time, stop_time, random_seed)
 
     def to_dict(self) -> dict:
         """Serializes the general properties to a dict"""
-        result = {self._KEY_RUN: self._run_id}
+        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,
+            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 = {self._KEY_INTERVAL: self.output_interval, self._KEY_PROCESS: self.output_process}
-        result[self._KEY_OUTPUT] = output_dict
+        result[self.KEY_SIMULATION] = simulation_dict
         return result
 
     @property
@@ -112,13 +97,3 @@ class GeneralProperties:
     def simulation_random_seed(self) -> int:
         """Returns the simulation random seed"""
         return self._simulation_random_seed
-
-    @property
-    def output_interval(self) -> int:
-        """Returns the output interval"""
-        return self._output_interval
-
-    @property
-    def output_process(self) -> int:
-        """Returns the output process"""
-        return self._output_process

fameio/{source → input}/scenario/scenario.py

@@ -3,30 +3,32 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import List, Dict
+from typing import Final
 
-from fameio.source.scenario.agent import Agent
-from fameio.source.scenario.contract import Contract
-from fameio.source.scenario.exception import get_or_default, get_or_raise
-from fameio.source.scenario.fameiofactory import FameIOFactory
-from fameio.source.scenario.generalproperties import GeneralProperties
-from fameio.source.scenario.stringset import StringSet
-from fameio.source.schema.schema import Schema
-from fameio.source.tools import keys_to_lower
+from fameio.input.metadata import Metadata
+from fameio.input.schema import Schema
+from fameio.tools import keys_to_lower
+from .agent import Agent
+from .contract import Contract
+from .exception import get_or_default, get_or_raise
+from .fameiofactory import FameIOFactory
+from .generalproperties import GeneralProperties
+from .stringset import StringSet
 
 
-class Scenario:
+class Scenario(Metadata):
     """Definition of a scenario"""
 
-    _KEY_SCHEMA = "Schema".lower()
-    _KEY_GENERAL = "GeneralProperties".lower()
-    _KEY_AGENTS = "Agents".lower()
-    _KEY_CONTRACTS = "Contracts".lower()
-    _KEY_STRING_SETS = "StringSets".lower()
+    KEY_SCHEMA: Final[str] = "Schema".lower()
+    KEY_GENERAL: Final[str] = "GeneralProperties".lower()
+    KEY_AGENTS: Final[str] = "Agents".lower()
+    KEY_CONTRACTS: Final[str] = "Contracts".lower()
+    KEY_STRING_SETS: Final[str] = "StringSets".lower()
 
     _MISSING_KEY = "Scenario definition misses required key '{}'."
 
     def __init__(self, schema: Schema, general_props: GeneralProperties) -> None:
+        super().__init__()
         self._schema = schema
         self._general_props = general_props
         self._string_sets = {}
@@ -38,46 +40,47 @@ class Scenario:
         """Parse scenario from provided `definitions` using given `factory`"""
         definitions = keys_to_lower(definitions)
 
-        schema = factory.new_schema_from_dict(get_or_raise(definitions, Scenario._KEY_SCHEMA, Scenario._MISSING_KEY))
+        schema = factory.new_schema_from_dict(get_or_raise(definitions, Scenario.KEY_SCHEMA, Scenario._MISSING_KEY))
         general_props = factory.new_general_properties_from_dict(
-            get_or_raise(definitions, Scenario._KEY_GENERAL, Scenario._MISSING_KEY)
+            get_or_raise(definitions, Scenario.KEY_GENERAL, Scenario._MISSING_KEY)
         )
         scenario = cls(schema, general_props)
+        scenario._extract_metadata(definitions)
 
-        for name, string_set_definition in get_or_default(definitions, Scenario._KEY_STRING_SETS, {}).items():
+        for name, string_set_definition in get_or_default(definitions, Scenario.KEY_STRING_SETS, {}).items():
             scenario.add_string_set(name, factory.new_string_set_from_dict(string_set_definition))
 
-        for agent_definition in get_or_default(definitions, Scenario._KEY_AGENTS, []):
+        for agent_definition in get_or_default(definitions, Scenario.KEY_AGENTS, []):
             scenario.add_agent(factory.new_agent_from_dict(agent_definition))
 
-        for multi_contract_definition in get_or_default(definitions, Scenario._KEY_CONTRACTS, []):
+        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 scenario
 
-    def to_dict(self) -> dict:
+    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_GENERAL: self.general_properties.to_dict(),
+            Scenario.KEY_SCHEMA: self.schema.to_dict(),
         }
         if self.string_sets:
-            result[Scenario._KEY_STRING_SETS] = {
+            result[Scenario.KEY_STRING_SETS] = {
                 name: string_set.to_dict() for name, string_set in self.string_sets.items()
             }
         if self.agents:
-            result[Scenario._KEY_AGENTS] = []
+            result[Scenario.KEY_AGENTS] = []
             for agent in self.agents:
-                result[Scenario._KEY_AGENTS].append(agent.to_dict())
+                result[Scenario.KEY_AGENTS].append(agent.to_dict())
         if self.contracts:
-            result[Scenario._KEY_CONTRACTS] = []
+            result[Scenario.KEY_CONTRACTS] = []
             for contract in self.contracts:
-                result[Scenario._KEY_CONTRACTS].append(contract.to_dict())
+                result[Scenario.KEY_CONTRACTS].append(contract.to_dict())
         return result
 
     @property
-    def agents(self) -> List[Agent]:
+    def agents(self) -> list[Agent]:
         """Returns all the agents of this scenario as a list"""
         return self._agents
 
@@ -86,7 +89,7 @@ class Scenario:
         self._agents.append(agent)
 
     @property
-    def contracts(self) -> List[Contract]:
+    def contracts(self) -> list[Contract]:
         """Returns all the contracts of this scenario as a list"""
         return self._contracts
 
@@ -105,7 +108,7 @@ class Scenario:
         return self._general_props
 
     @property
-    def string_sets(self) -> Dict[str, StringSet]:
+    def string_sets(self) -> dict[str, StringSet]:
         """Returns StringSets of this scenario"""
         return self._string_sets
 

fameio/input/scenario/stringset.py

@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Union, Final
+
+from fameio.input.metadata import Metadata, MetadataComponent, ValueContainer
+from fameio.tools import keys_to_lower
+from .exception import log_and_raise
+
+
+class StringSet(Metadata):
+    """Hosts a StringSet in the given format"""
+
+    KEY_VALUES: Final[str] = "Values".lower()
+
+    ValueType = Union[list[str], dict[str, dict]]
+    StringSetType = dict[str, Union[dict, ValueType]]
+
+    _ERR_KEY_MISSING = "Missing mandatory key '{}' in StringSet definition {}."
+
+    def __init__(self, definitions=None):
+        super().__init__(definitions)
+        self._value_container: ValueContainer = ValueContainer(definitions)
+
+    @classmethod
+    def from_dict(cls, definition: StringSetType) -> StringSet:
+        """Returns StringSet initialised from `definition`"""
+        string_set = cls(definition)
+        definition = keys_to_lower(definition)
+        if cls.KEY_VALUES in definition:
+            string_set._value_container = ValueContainer(definition[cls.KEY_VALUES])
+        else:
+            log_and_raise(cls._ERR_KEY_MISSING.format(cls.KEY_VALUES, definition))
+        return string_set
+
+    def _to_dict(self) -> dict[str, dict[str, dict[str, dict[str, dict]]]]:
+        return {self.KEY_VALUES: self._value_container.to_dict()}
+
+    @property
+    def values(self) -> dict[str, MetadataComponent]:
+        """Returns values and their associated MetadataComponent"""
+        return self._value_container.values
+
+    def is_in_set(self, key: str) -> bool:
+        """Returns True if `key` is a valid name in this StringSet"""
+        return self._value_container.has_value(key)

fameio/{source → input}/schema/__init__.py

@@ -1,8 +1,8 @@
-# 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 .agenttype import AgentType
 from .attribute import AttributeSpecs, AttributeType
-from .exception import SchemaException
+from .java_packages import JavaPackages
 from .schema import Schema