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

fameio-3.0.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+CHANGELOG.md,sha256=PLSHTL6fgGuJ_zdIDiJi_LoJ5HpekTlG2MooflQ14ls,13801
+fameio/__init__.py,sha256=LiE7kRXW0pMIB4hTPC0T_ppGz9O0swd0Ca1-b99hOMc,229
+fameio/cli/__init__.py,sha256=xAS0gRfzq1qepCW6PjIozRC6t3DOxzdNvHU9beFOGHU,167
+fameio/cli/convert_results.py,sha256=-nAAuO_CznggZnZHeGctP_uXcQsQGjTDDZmHAqlBMJQ,3438
+fameio/cli/make_config.py,sha256=Dbn_ITlhpumc-bK9ONKZyGnyYLXsc8YIWQN9OHLBHe4,2712
+fameio/cli/options.py,sha256=2XNwCAloiy_lC77C7LEngMvvT7rVmzASeE_JxQlpHak,1257
+fameio/cli/parser.py,sha256=fR28uzjf6MV3do4AefrXbRu2m4-x0bR-Xn-1Di1e0Lk,8391
+fameio/input/__init__.py,sha256=mDpz4hKZqpzrxtuvwK-eZl-zwHhegRbiH5ew1LpjaAg,550
+fameio/input/loader/__init__.py,sha256=ShZq2zBGz3-423Fd6DLCi1wAtD2JDgFiaknJ24lGToU,2659
+fameio/input/loader/controller.py,sha256=Ph7QvGwbJJ4MNb21nPiYJNTdjpPcRFms95Fd-evzGD0,5800
+fameio/input/loader/loader.py,sha256=uVCUXN2FqtO058zxDBQth2rabP8BPtInMZnAcI7SX8Q,5060
+fameio/input/metadata.py,sha256=l28BPnwjb62RRt-tBJ-HVmOJVO1QIRlKdMx-gjoP_mw,5957
+fameio/input/resolver.py,sha256=86APkFnupWSJNAaX4RP_SOYNv5W3WUwV_I6Iptkur_Q,1917
+fameio/input/scenario/__init__.py,sha256=azglGZTK39jpkDOmeVAhiLH9zIsUx2SZ_umQIlJiq6Q,322
+fameio/input/scenario/agent.py,sha256=Zl83x3U1f4nVv1gbCOhjQ911u-GwWXoWR5_QW0cRHtM,4377
+fameio/input/scenario/attribute.py,sha256=-u-dCzs8lUhSEc98hDot28nl6BLA7sEzAg9GzmNci4k,9635
+fameio/input/scenario/contract.py,sha256=D6iy-oVNwIqQxeZQ3rITERwIgFRrhzYHRysygn-ceDk,9046
+fameio/input/scenario/exception.py,sha256=zavHELqzpIJvb_4GhskYQyi2u5Y6LppwWQt-yGecMQY,1434
+fameio/input/scenario/fameiofactory.py,sha256=_8R3q_e5lHGd75DDbgJvTX6PJNn0i6nZSnW4DyGgdOA,1558
+fameio/input/scenario/generalproperties.py,sha256=gTSLS0bgoZYAMDYhaFTGcJxipgik9AntSPihQBIcX6k,3504
+fameio/input/scenario/scenario.py,sha256=f9gIV_FdtS52L_nWdstwSoXlN8gL7ovxGPAaWpEzOjc,4608
+fameio/input/scenario/stringset.py,sha256=ORW0_4M9CGtB5NQAzQhzZJliHmyW0yQjG_tzMjnRxUw,1814
+fameio/input/schema/__init__.py,sha256=V1m0Cx97lNeZwaQBFo-a5WMbohdsCwDfvmjtxD2vaBo,271
+fameio/input/schema/agenttype.py,sha256=NLcdIuMKjFsqhHG9zisYaHDnP7eDOctHWG1yEH9_ugg,5149
+fameio/input/schema/attribute.py,sha256=4nH-lA0Wh7pe8ZPOWXjuVkPa6Jl5cYQnxU5_e4Y54L0,11369
+fameio/input/schema/java_packages.py,sha256=jkwEgR3mOGky-cvSgR3pGQEJ84hXN5NZS_oyoeYt-9g,2845
+fameio/input/schema/schema.py,sha256=-Hm7r9Hka8NDnNZLe9GCeaULcBgvvhHQhEYjxQ4VzTg,3039
+fameio/input/validator.py,sha256=-X0aEEzKj6s5laxXhDzGcwAa0f4Ssp5waLmuriO-3u0,18359
+fameio/input/writer.py,sha256=TyFkS3KKdAaXiMq-yLDriwOcy65-P5ZeEtzOtUM1y38,12810
+fameio/logs.py,sha256=JxT4JkyKCxxB9QybGOhAcncCexmoIx6_dkGczjG-h8A,3992
+fameio/output/__init__.py,sha256=IQm0MNOXkhBexiMXBoNZDK5xHUYgazH7oXm-lc0Vm04,109
+fameio/output/agent_type.py,sha256=6niFUKOhxUdGw98NUVNtIM543hAQaCkyy7hacxlc9dU,4328
+fameio/output/conversion.py,sha256=2DQ6T2AuU0iDrKsUQ1HcM1TO_prqlENtq2n28wPKwcU,3991
+fameio/output/csv_writer.py,sha256=hU3TM_c8bltY_j_6NZInNB7fyLsNZsYsOrfVvDNYwwE,5117
+fameio/output/data_transformer.py,sha256=2fBXQ8byS3Lhsmocr2AB5B_I9NmDQrwzIViUtQeKYYg,5473
+fameio/output/input_dao.py,sha256=aTNdRM_uaVXB8X7EkWZ3eEd1IMH93Bfx8jCpFvhlBVE,6983
+fameio/output/output_dao.py,sha256=f7xnsjY80E6OolHlFDzWkJG2J86wxXJJ2nRRmgUnVVc,4085
+fameio/output/reader.py,sha256=wiTCkmETtcZR_ybb4CxnfyTtBF74bTNp2w96fFD8Qo0,5097
+fameio/output/yaml_writer.py,sha256=YIUKQB10BnDF9LghLf5bD23ryUI340lGxslB5j88_dk,805
+fameio/scripts/__init__.py,sha256=Owg46sNUIkq7qLJpfa75Cuhjtl3HGkR6l1-LEaNE54A,727
+fameio/scripts/__init__.py.license,sha256=2-OqCNxP4504xY2XQqseYypJi1_Qx4xJSzO3t7c3ACM,107
+fameio/scripts/convert_results.py,sha256=Olrw4l9nGzstgdVyhJJthHCKyaTubVXSlM26729Sjmk,4173
+fameio/scripts/convert_results.py.license,sha256=2-OqCNxP4504xY2XQqseYypJi1_Qx4xJSzO3t7c3ACM,107
+fameio/scripts/make_config.py,sha256=LvwXbBlaGdKC25BRlk4LJDEwvZzxzCzYyVewtyHhIMM,1351
+fameio/scripts/make_config.py.license,sha256=2-OqCNxP4504xY2XQqseYypJi1_Qx4xJSzO3t7c3ACM,107
+fameio/series.py,sha256=BMnJMAdx38duao5w9165b9XB1JRIFOLZ83cjzN5wRUg,9110
+fameio/time.py,sha256=iiCVpEmBSxHgKft_X-E_D-dpOT-L2Y_xN-6pVFtJhDQ,6949
+fameio/tools.py,sha256=8Ia-J-mgjf1NCXMvjLDj10hDwEKzp6jS6eq6z8W005w,1056
+fameio-3.0.0.dist-info/entry_points.txt,sha256=jvQVfwJjZXPWQjJlhj1Dt6PTeblryTc1GxjKeK90twI,123
+fameio-3.0.0.dist-info/LICENSE.txt,sha256=eGHBZnhr9CWjE95SWjRfmhtK1lvVn5X4Fpf3KrrAZDg,10391
+fameio-3.0.0.dist-info/LICENSES/Apache-2.0.txt,sha256=eGHBZnhr9CWjE95SWjRfmhtK1lvVn5X4Fpf3KrrAZDg,10391
+fameio-3.0.0.dist-info/LICENSES/CC-BY-4.0.txt,sha256=y9WvMYKGt0ZW8UXf9QkZB8wj1tjJrQngKR7CSXeSukE,19051
+fameio-3.0.0.dist-info/LICENSES/CC0-1.0.txt,sha256=9Ofzc7m5lpUDN-jUGkopOcLZC3cl6brz1QhKInF60yg,7169
+fameio-3.0.0.dist-info/METADATA,sha256=q0ibxLgLicduMZ0Xe9fvYAPaY8FMjOu66_0pTC-QRAQ,37270
+fameio-3.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fameio-3.0.0.dist-info/RECORD,,

fameio/source/__init__.py

@@ -1,8 +0,0 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .path_resolver import PathResolver
-from .time import FameTime
-from .validator import SchemaValidator
-from .writer import ProtoWriter, ProtoWriterException

fameio/source/loader.py

@@ -1,181 +0,0 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import os
-from pathlib import Path
-from fnmatch import fnmatch
-from typing import IO, Any, Callable
-
-import yaml
-from fameio.source.logs import log_and_raise_critical, log
-from fameio.source.path_resolver import PathResolver
-
-DISABLING_YAML_FILE_PREFIX = "IGNORE_"
-
-CRIT_NO_YAML_SUFFIX = "File must have a `.yaml` or `.yml` suffix. Received `-f/--file {}` instead."
-
-FILE_ENCODINGS = [None]
-
-
-class Args:
-    def __init__(self, file_string, node_string):
-        self.file_string = file_string
-        self.node_string = node_string
-
-
-def read_args(loader, args):
-    """Returns two Strings to be interpreted as files to be read and a sub-node_address from the given `args`"""
-    node_string = ""
-    file_string = None
-    if isinstance(args, yaml.nodes.ScalarNode):
-        file_string = loader.construct_scalar(args)
-        log().debug("Found instance `ScalarNode` in {}".format(file_string))
-    elif isinstance(args, yaml.nodes.SequenceNode):
-        argument_list = loader.construct_sequence(args)
-        if len(argument_list) not in [1, 2]:
-            log_and_raise_critical("!include supports but one or two arguments in list")
-        elif len(argument_list) == 2:
-            node_string = argument_list[1]
-        file_string = argument_list[0]
-        log().debug("Found instance `SequenceNode` in {}".format(file_string))
-    elif isinstance(args, yaml.nodes.MappingNode):
-        argument_map = loader.construct_mapping(args)
-        for key, value in argument_map.items():
-            if key.lower() == "file":
-                file_string = value
-            elif key.lower() == "node":
-                node_string = value
-            else:
-                log_and_raise_critical("!include supports only keys 'file' and 'node'")
-        if not file_string:
-            log_and_raise_critical("!include: file must be specified.")
-    else:
-        log_and_raise_critical("YAML node type not implemented: {}".format(args))
-    return Args(file_string, node_string)
-
-
-def split_nodes(node_string):
-    """Returns a list of nodes created from the given `node_string`"""
-    log().debug("Splitting given node_string `{}`".format(node_string))
-    return node_string.split(":")
-
-
-class FameYamlLoader(yaml.SafeLoader):
-    """Custom YAML Loader for `!include` constructor"""
-
-    def __init__(self, stream: IO, path_resolver=PathResolver()) -> None:
-        log().debug("Initialize custom YAML loader")
-        self._path_resolver = path_resolver
-        try:
-            self._root_path = os.path.split(stream.name)[0]
-        except AttributeError:
-            self._root_path = os.path.curdir
-        super().__init__(stream)
-
-    @property
-    def root_path(self) -> str:
-        return self._root_path
-
-    @property
-    def path_resolver(self) -> PathResolver:
-        return self._path_resolver
-
-
-def make_yaml_loader_builder(
-    path_resolver: PathResolver,
-) -> Callable[[Any], FameYamlLoader]:
-    """Utility function used to control the creation of a FameYamlLoader by the YAML library."""
-    return lambda stream: FameYamlLoader(stream, path_resolver)
-
-
-def resolve_imported_path(loader: FameYamlLoader, included_path: str):
-    """
-    Returns a list of file paths matching the given `included_path` based on path resolution performed by the loader.
-
-    Ignores the files starting with `DISABLING_YAML_FILE_PREFIX`
-    """
-    file_list = loader.path_resolver.resolve_yaml_imported_file_pattern(loader.root_path, included_path)
-
-    ignore_filter = "*" + DISABLING_YAML_FILE_PREFIX + "*"
-    cleaned_file_list = []
-    for file in file_list:
-        if fnmatch(file, ignore_filter):
-            log().debug("Ignoring file {} due to prefix {}".format(file, DISABLING_YAML_FILE_PREFIX))
-        else:
-            cleaned_file_list.append(file)
-    if not cleaned_file_list:
-        log_and_raise_critical("Failed to find any file matching the `!include` directive `{}`".format(included_path))
-    log().debug("Collected file(s) `{}` from given included path `{}`".format(cleaned_file_list, included_path))
-    return cleaned_file_list
-
-
-def read_data_from_file(file, node_address, path_resolver: PathResolver):
-    """Returns data of the specified `node_address` from the specified `file`"""
-    data = yaml.load(file, make_yaml_loader_builder(path_resolver))
-    for node in node_address:
-        if node:
-            try:
-                data = data[node]
-            except KeyError:
-                log_and_raise_critical("'!include_node [{}, {}]': Cannot find '{}'.".format(file, node_address, node))
-    log().debug("Searched file `{}` for node `{}`".format(file, node_address))
-    return data
-
-
-def join_data(new_data, previous_data):
-    """Joins data from multiple files if both are in list format, otherwise returns"""
-    if not previous_data:
-        return new_data
-    if isinstance(new_data, list) and isinstance(previous_data, list):
-        previous_data.extend(new_data)
-        return previous_data
-    else:
-        log_and_raise_critical("!include can only combine list-like elements from multiple files!")
-
-
-def construct_include(loader: FameYamlLoader, args: yaml.Node) -> Any:
-    """
-    Loads one or many YAML file(s) with specifications provided in `args` in different formats
-    To load all content of a specified file, use:
-        !include "path/to/file.yaml"
-    To load only specific content (e.g. data of "Super:Sub:Node") from a given file, use:
-        !include ["path/to/file.yml", "Super:Sub:Node"]
-    For a slightly more verbose version of the above commands, use a dictionary argument:
-        !include {"file":"path/to/file.yml", "node": "Super:Sub:Node"}
-
-    Instead of "path/to/file.yaml" one can also use asterisks to select multiple files, e.g. "path/to/files/*.yaml"
-    The given file path is either
-      * relative to the path of the including YAML file, if it starts with a character other than "/"
-      * an absolute path if its starts with "/"
-    """
-    args = read_args(loader, args)
-    nodes = split_nodes(args.node_string)
-    files = resolve_imported_path(loader, args.file_string)
-
-    joined_data = None
-    for file_name in files:
-        with open(file_name, "r", encoding=FILE_ENCODINGS[0]) as open_file:
-            data = read_data_from_file(open_file, nodes, loader.path_resolver)
-            joined_data = join_data(data, joined_data)
-    log().debug("Joined all files `{}` to joined data `{}`".format(files, joined_data))
-    return joined_data
-
-
-FameYamlLoader.add_constructor("!include", construct_include)
-
-
-def load_yaml(yaml_file_path: Path, path_resolver=PathResolver(), encoding: str = None) -> dict:
-    """Loads the yaml file from given `yaml_file_path` and returns its content"""
-    log().info("Loading yaml from {}".format(yaml_file_path))
-    FILE_ENCODINGS[0] = encoding
-    with open(yaml_file_path, "r", encoding=encoding) as configfile:
-        data = yaml.load(configfile, make_yaml_loader_builder(path_resolver))
-    FILE_ENCODINGS[0] = None
-    return data
-
-
-def check_for_yaml_file_type(yaml_file: Path) -> None:
-    """Raises Exception if given `yaml_file` has no YAML-associated file suffix"""
-    if yaml_file.suffix.lower() not in [".yaml", ".yml"]:
-        log_and_raise_critical(CRIT_NO_YAML_SUFFIX.format(yaml_file))

fameio/source/metadata.py

@@ -1,32 +0,0 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-from abc import ABC
-from typing import Dict, Any
-
-from fameio.source.tools import keys_to_lower
-
-
-class Metadata(ABC):
-    """Hosts Metadata"""
-
-    _KEY_METADATA = "MetaData".lower()
-
-    def __init__(self):
-        self._metadata = {}
-
-    @property
-    def metadata(self) -> dict:
-        """Returns list of metadata or an empty list if no metadata are defined"""
-        return self._metadata
-
-    def _extract_metadata(self, definitions: Dict[str, Any]) -> None:
-        """If metadata is found in definitions, it is extracted and set"""
-        definitions = keys_to_lower(definitions)
-        if self._KEY_METADATA in definitions:
-            self._metadata = definitions[self._KEY_METADATA]
-
-    def _enrich_with_metadata(self, data: Dict) -> Dict:
-        """Returns data enriched with metadata field"""
-        data[self._KEY_METADATA] = self._metadata
-        return data

fameio/source/path_resolver.py

@@ -1,34 +0,0 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import glob
-import os
-from typing import List, Optional
-
-
-class PathResolver:
-    """Class responsible for locating files referenced in a scenario.
-
-    Such files can be the ones referenced via the YAML `!include` extension, or simply the data files (time_series)
-    referenced in attributes.
-
-    This class provides a default behaviour that can easily be customized by the caller."""
-
-    def resolve_yaml_imported_file_pattern(self, root_path: str, file_pattern: str) -> List[str]:
-        """Returns a list of file paths matching the given `file_pattern` based on the configured resolver."""
-        absolute_path = os.path.abspath(os.path.join(root_path, file_pattern))
-        return glob.glob(absolute_path)
-
-    def resolve_series_file_path(self, file_name: str) -> Optional[str]:
-        """Returns the absolute file path for the given series (relative) file name, or None on failure."""
-        if os.path.isabs(file_name):
-            return file_name
-
-        # try to locate in the current dir
-        file_path = os.path.join(os.path.curdir, file_name)
-        if os.path.exists(file_path):
-            return file_path
-
-        # not found
-        return None

fameio/source/scenario/attribute.py

@@ -1,130 +0,0 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-from __future__ import annotations
-
-from typing import Any, Dict, List
-
-from fameio.source.scenario.exception import log_and_raise
-
-
-class Attribute:
-    """An Attribute of an agent in a scenario"""
-
-    _VALUE_MISSING = "Value not specified for Attribute '{}' - leave out if default shall be used (if defined)."
-    _LIST_EMPTY = "Attribute '{}' was assigned an empty list - please remove or fill empty assignments."
-    _DICT_EMPTY = "Attribute '{}' was assigned an empty dictionary - please remove or fill empty assignments."
-    _MIXED_DATA = "Attribute '{}' was assigned a list with mixed complex and simple entries - please fix."
-
-    _NAME_STRING_SEPARATOR = "."
-
-    def __init__(self, name: str, definitions) -> None:
-        """Parses an Attribute's definition"""
-        self._full_name = name
-
-        if definitions is None:
-            log_and_raise(Attribute._VALUE_MISSING.format(name))
-
-        if isinstance(definitions, dict):
-            self._value = None
-            self._nested_list = None
-            self._nested = Attribute._build_attribute_dict(name, definitions)
-        elif Attribute._is_list_of_dict(name, definitions):
-            self._nested = None
-            self._value = None
-            self._nested_list = []
-            for entry in definitions:
-                self._nested_list.append(Attribute._build_attribute_dict(name, entry))
-        else:
-            self._nested = None
-            self._nested_list = None
-            self._value = definitions
-
-    @staticmethod
-    def _build_attribute_dict(name: str, definitions: Dict[str, Any]) -> Dict[str, "Attribute"]:
-        """Returns a new dictionary containing Attributes generated from given `definitions`"""
-        if not definitions:
-            log_and_raise(Attribute._DICT_EMPTY.format(name))
-
-        inner_elements = {}
-        for nested_name, value in definitions.items():
-            full_name = name + Attribute._NAME_STRING_SEPARATOR + nested_name
-            inner_elements[nested_name] = Attribute(full_name, value)
-        return inner_elements
-
-    @staticmethod
-    def _is_list_of_dict(name: str, definitions: Any) -> bool:
-        """Returns True if given `definitions` is a list of dict"""
-        if isinstance(definitions, list):
-            if not definitions:
-                log_and_raise(Attribute._LIST_EMPTY.format(name))
-
-            all_dicts = no_dicts = True
-            for item in definitions:
-                if not isinstance(item, dict):
-                    all_dicts = False
-                else:
-                    no_dicts = False
-            if (not all_dicts) and (not no_dicts):
-                log_and_raise(Attribute._MIXED_DATA.format(name))
-            return all_dicts
-        return False
-
-    @property
-    def generic_content(self) -> Any:
-        """Returns the full content of the attribute (and its children) as a generic value"""
-        if self.has_value:
-            return self.value
-        elif self.has_nested_list:
-            result = []
-            for attr_dict in self.nested_list:
-                inner_elements = {}
-                for name, attr in attr_dict.items():
-                    inner_elements[name] = attr.generic_content
-                result.append(inner_elements)
-            return result
-        elif self.has_nested:
-            result = {}
-            for name, attr in self.nested.items():
-                result[name] = attr.generic_content
-            return result
-        else:
-            log_and_raise(Attribute._VALUE_MISSING.format(self._full_name))
-
-    @property
-    def has_value(self) -> bool:
-        """Returns True if Attribute has any value assigned"""
-        return self._value is not None
-
-    @property
-    def value(self) -> Any:
-        return self._value
-
-    @property
-    def has_nested(self) -> bool:
-        """Returns True if nested Attributes are present"""
-        return bool(self._nested)
-
-    @property
-    def nested(self) -> Dict[str, Attribute]:
-        """Returns dictionary of all nested Attributes"""
-        assert self.has_nested
-        return self._nested
-
-    def get_nested_by_name(self, key: str) -> Attribute:
-        """Returns nested Attribute by specified name"""
-        return self._nested[key]
-
-    @property
-    def has_nested_list(self) -> bool:
-        """Returns True if list of nested items is present"""
-        return bool(self._nested_list)
-
-    @property
-    def nested_list(self) -> List[Dict[str, "Attribute"]]:
-        """Return list of all nested Attribute dictionaries"""
-        assert self.has_nested_list
-        return self._nested_list
-
-    def __repr__(self) -> str:
-        return self._full_name

fameio/source/scenario/stringset.py

@@ -1,51 +0,0 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-from typing import Dict, List, Union
-
-from fameio.source.metadata import Metadata
-from fameio.source.scenario.exception import log_and_raise
-from fameio.source.tools import keys_to_lower
-
-
-class StringSet(Metadata):
-    """Hosts a StringSet in the given format"""
-
-    ValueType = Union[List[str], Dict[str, Dict]]
-    StringSetType = Dict[str, Union[Dict, ValueType]]
-
-    _ERR_NO_STRING_SET_VALUES = "Missing mandatory key '{}' in StringSet definition {}."
-
-    _KEY_VALUES = "Values".lower()
-
-    def __init__(self):
-        super().__init__()
-        self._values = {}
-
-    @classmethod
-    def from_dict(cls, definition: StringSetType) -> "StringSet":
-        """Returns StringSet initialised from `definition`"""
-        string_set = cls()
-        string_set._extract_metadata(definition)
-        definition = keys_to_lower(definition)
-        if cls._KEY_VALUES in definition:
-            string_set._values = string_set._read_values(definition)
-        else:
-            log_and_raise(cls._ERR_NO_STRING_SET_VALUES.format(cls._KEY_VALUES, definition))
-        return string_set
-
-    def _read_values(self, definition: ValueType) -> Dict[str, Dict]:
-        """Ensures values are returned as dictionary representation by converting `definitions` of type 'List[str]'"""
-        values = definition[self._KEY_VALUES]
-        if isinstance(values, list):
-            return {name: {} for name in values}
-        return values
-
-    def to_dict(self) -> Dict:
-        """Serializes the StringSet to a dict"""
-        result = {self._KEY_VALUES: self._values}
-        return self._enrich_with_metadata(result)
-
-    def is_in_set(self, key: str) -> bool:
-        """Returns True if `key` is a valid name in this StringSet"""
-        return key in self._values

fameio/source/schema/agenttype.py

@@ -1,132 +0,0 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-from __future__ import annotations
-
-from typing import Dict, List, Any
-
-from fameio.source.logs import log_error_and_raise, log
-from fameio.source.schema.exception import SchemaException
-from fameio.source.schema.attribute import AttributeSpecs
-from fameio.source.tools import keys_to_lower
-
-
-class AgentType:
-    """Schema definitions for an Agent type"""
-
-    _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._outputs = {}
-        self._metadata = {}
-
-    @classmethod
-    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
-
-        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
-                agent_type._attributes[attribute_name] = AttributeSpecs(full_name, attribute_details)
-        else:
-            log().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:
-            log().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().debug(AgentType._NO_OUTPUTS.format(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:
-            log().debug(AgentType._NO_METADATA.format(name))
-
-        return agent_type
-
-    @staticmethod
-    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 = 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.keys()]):
-            return product_names
-        else:
-            log_error_and_raise(SchemaException(AgentType._ERR_PRODUCTS_NO_STRING.format(agent_type, product_names)))
-
-    @property
-    def name(self) -> str:
-        """Returns the agent type name"""
-        return self._name
-
-    @property
-    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