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

fameio/source/schema/schema.py

@@ -1,45 +1,74 @@
-# 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 Dict
+import ast
+from typing import Dict, Optional
 
-from fameio.source.logs import log_error_and_raise
+from fameio.source.logs import log_error_and_raise, log
 from fameio.source.schema.agenttype import AgentType
 from fameio.source.schema.exception import SchemaException
+from fameio.source.schema.java_packages import JavaPackages
 from fameio.source.tools import keys_to_lower
 
 
 class Schema:
     """Definition of a schema"""
 
-    _AGENT_TYPES_MISSING = "Keyword AgentTypes not found in Schema."
+    _ERR_AGENT_TYPES_MISSING = "Required keyword `AgentTypes` missing in Schema."
+    _ERR_AGENT_TYPES_EMPTY = "`AgentTypes` must not be empty - at least one type of agent is required."
+    _WARN_MISSING_PACKAGES = "No `JavaPackages` defined Schema. Future versions of fameio will require it."
+
     _KEY_AGENT_TYPE = "AgentTypes".lower()
+    _KEY_PACKAGES = "JavaPackages".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
+        self._packages: Optional[JavaPackages] = None
 
     @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)
+            log_error_and_raise(SchemaException(Schema._ERR_AGENT_TYPES_MISSING))
+        schema = cls(definitions)
+        agent_types = definitions[Schema._KEY_AGENT_TYPE]
+        if len(agent_types) == 0:
+            log_error_and_raise(SchemaException(Schema._ERR_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
+
+        if Schema._KEY_PACKAGES in definitions:
+            schema._packages = JavaPackages.from_dict(definitions[Schema._KEY_PACKAGES])
+        else:
+            log().warning(Schema._WARN_MISSING_PACKAGES)
+            schema._packages = JavaPackages()
+        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"""
         return self._agent_types
+
+    @property
+    def packages(self) -> JavaPackages:
+        """Returns JavaPackages, i.e. names where model classes are defined in"""
+        return self._packages

fameio/source/series.py

@@ -1,48 +1,171 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+import math
+import os
+from enum import Enum, auto
+from pathlib import Path
+from typing import Dict, Union, Tuple, Any, List
 
-from typing import Dict, Union
+import pandas as pd
+from fameprotobuf.InputFile_pb2 import InputData
+from google.protobuf.internal.wire_format import INT64_MIN, INT64_MAX
 
-from fameio.source.logs import log_error_and_raise
+from fameio.source import PathResolver
+from fameio.source.logs import log_error_and_raise, log
+from fameio.source.time import ConversionException, FameTime
+from fameio.source.tools import clean_up_file_name
 
 
-class SeriesManagementException(Exception):
+class TimeSeriesException(Exception):
     """Indicates that an error occurred during management of time series"""
 
     pass
 
 
+class Entry(Enum):
+    ID = auto()
+    NAME = auto()
+    DATA = auto()
+
+
 class TimeSeriesManager:
     """Manages matching of files to time series ids and their protobuf representation"""
 
-    _ALREADY_REGISTERED = "File '{}' was already registered."
+    _TIMESERIES_RECONSTRUCTION_PATH = "./timeseries/"
+    _CONSTANT_IDENTIFIER = "Constant value: {}"
+    _KEY_ROW_TIME = "timeStep"
+    _KEY_ROW_VALUE = "value"
+
+    _ERR_FILE_NOT_FOUND = "Cannot find Timeseries file '{}'"
+    _ERR_CORRUPT_TIME_SERIES_KEY = "TimeSeries file '{}' corrupt: At least one entry in first column isn't a timestamp."
+    _ERR_CORRUPT_TIME_SERIES_VALUE = "TimeSeries file '{}' corrupt: At least one entry in value column isn't numeric."
+    _ERR_NON_NUMERIC = "Values in TimeSeries must be numeric but was: '{}'"
+    _ERR_NAN_VALUE = "Values in TimeSeries must not be missing or NaN."
+    _ERR_UNREGISTERED_SERIES = "No timeseries registered with identifier '{}' - was the Scenario validated?"
+    _WARN_NO_DATA = "No timeseries stored in timeseries manager. Double check if you expected timeseries."
 
-    def __init__(self):
+    def __init__(self, path_resolver: PathResolver = PathResolver()) -> None:
+        self._path_resolver = path_resolver
         self._id_count = -1
-        self._ids_of_time_series = {}
+        self._series_by_id: Dict[Union[str, int, float], Dict[Entry, Any]] = {}
 
-    def _get_time_series_id(self, name: Union[str, int, float]) -> int:
-        """Returns the id assigned to the given file name"""
-        return self._ids_of_time_series.get(name)
+    def register_and_validate(self, identifier: Union[str, int, float]) -> None:
+        """
+        Registers given timeseries `identifier` and validates associated timeseries
 
-    def _time_series_is_registered(self, name: Union[str, int, float]) -> bool:
-        """Returns True if the file is already registered"""
-        return name in self._ids_of_time_series.keys()
+        Args:
+            identifier: to be registered - either a single numeric value or a string pointing to a timeseries file
 
-    def _register_time_series(self, name: Union[str, int, float]) -> None:
-        """Assigns an id to the given file or raises an Exception if the file is already registered"""
-        if not self._time_series_is_registered(name):
-            self._id_count += 1
-            self._ids_of_time_series[name] = self._id_count
+        Raises:
+            TimeSeriesException: if file was not found, ill-formatted, or value was invalid
+        """
+        if not self._time_series_is_registered(identifier):
+            self._register_time_series(identifier)
+
+    def _time_series_is_registered(self, identifier: Union[str, int, float]) -> bool:
+        """Returns True if the value was already registered"""
+        return identifier in self._series_by_id.keys()
+
+    def _register_time_series(self, identifier: Union[str, int, float]) -> None:
+        """Assigns an id to the given `identifier` and loads the time series into a dataframe"""
+        self._id_count += 1
+        name, series = self._get_name_and_dataframe(identifier)
+        self._series_by_id[identifier] = {Entry.ID: self._id_count, Entry.NAME: name, Entry.DATA: series}
+
+    def _get_name_and_dataframe(self, identifier: Union[str, int, float]) -> Tuple[str, pd.DataFrame]:
+        """Returns name and DataFrame containing the series obtained from the given `identifier`"""
+        if isinstance(identifier, str):
+            series_path = self._path_resolver.resolve_series_file_path(Path(identifier).as_posix())
+            if series_path and os.path.exists(series_path):
+                data = pd.read_csv(series_path, sep=";", header=None, comment="#")
+                try:
+                    return identifier, self._check_and_convert_series(data)
+                except TypeError as e:
+                    log_error_and_raise(TimeSeriesException(self._ERR_CORRUPT_TIME_SERIES_VALUE.format(identifier), e))
+                except ConversionException:
+                    log_error_and_raise(TimeSeriesException(self._ERR_CORRUPT_TIME_SERIES_KEY.format(identifier)))
+            else:
+                log_error_and_raise(TimeSeriesException(self._ERR_FILE_NOT_FOUND.format(identifier)))
         else:
-            log_error_and_raise(SeriesManagementException(TimeSeriesManager._ALREADY_REGISTERED.format(name)))
+            return self._create_timeseries_from_value(identifier)
+
+    def _check_and_convert_series(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Ensures validity of time series and convert to required format for writing to disk"""
+        data = data.apply(
+            lambda r: [FameTime.convert_string_if_is_datetime(r[0]), self._assert_valid(r[1])],
+            axis=1,
+            result_type="expand",
+        )
+        return data
+
+    @staticmethod
+    def _assert_valid(value: Any) -> float:
+        """Returns the given `value` if it is a numeric value other than NaN"""
+        try:
+            value = float(value)
+        except ValueError:
+            log_error_and_raise(TypeError(TimeSeriesManager._ERR_NON_NUMERIC.format(value)))
+        if math.isnan(value):
+            log_error_and_raise(TypeError(TimeSeriesManager._ERR_NAN_VALUE))
+        return value
 
-    def save_get_time_series_id(self, name: Union[str, int, float]) -> int:
-        """Returns the id of the time series file name - if the file is not yet registered, assigns an id"""
-        if not self._time_series_is_registered(name):
-            self._register_time_series(name)
-        return self._get_time_series_id(name)
+    @staticmethod
+    def _create_timeseries_from_value(value: Union[int, float]) -> Tuple[str, pd.DataFrame]:
+        """Returns name and dataframe for a new static timeseries created from the given `value`"""
+        if math.isnan(value):
+            log_error_and_raise(TimeSeriesException(TimeSeriesManager._ERR_NAN_VALUE))
+        data = pd.DataFrame({0: [INT64_MIN, INT64_MAX], 1: [value, value]})
+        return TimeSeriesManager._CONSTANT_IDENTIFIER.format(value), data
+
+    def get_series_id_by_identifier(self, identifier: Union[str, int, float]) -> int:
+        """
+        Returns id for a previously stored time series by given `identifier`
+
+        Args:
+            identifier: to get the unique ID for
+
+        Returns:
+            unique ID for the given identifier
+
+        Raises:
+            TimeSeriesException: if identifier was not yet registered
+        """
+        if not self._time_series_is_registered(identifier):
+            log_error_and_raise(TimeSeriesException(self._ERR_UNREGISTERED_SERIES.format(identifier)))
+        return self._series_by_id.get(identifier)[Entry.ID]
+
+    def get_all_series(self) -> List[Tuple[int, str, pd.DataFrame]]:
+        """Returns iterator over id, name and dataframe of all stored series"""
+        if len(self._series_by_id) == 0:
+            log().warning(self._WARN_NO_DATA)
+        return [(v[Entry.ID], v[Entry.NAME], v[Entry.DATA]) for v in self._series_by_id.values()]
+
+    def reconstruct_time_series(self, timeseries: List[InputData.TimeSeriesDao]) -> None:
+        """Reconstructs and stores time series from given list of `timeseries_dao`"""
+        for one_series in timeseries:
+            self._id_count += 1
+            reconstructed = {Entry.ID: one_series.seriesId}
+            if len(one_series.row) == 1:
+                reconstructed[Entry.NAME] = one_series.row[0].value
+                reconstructed[Entry.DATA] = None
+            else:
+                reconstructed[Entry.NAME] = self._get_cleaned_file_name(one_series.seriesName)
+                reconstructed[Entry.DATA] = pd.DataFrame(
+                    [{self._KEY_ROW_TIME: item.timeStep, self._KEY_ROW_VALUE: item.value} for item in one_series.row]
+                )
+            self._series_by_id[one_series.seriesId] = reconstructed
+
+    def _get_cleaned_file_name(self, timeseries_name: str):
+        if timeseries_name.lower().endswith(".csv"):
+            filename = Path(timeseries_name).name
+        else:
+            filename = clean_up_file_name(timeseries_name) + ".csv"
+        return str(Path(self._TIMESERIES_RECONSTRUCTION_PATH, filename))
 
-    def get_ids_of_series_by_name(self) -> Dict[Union[str, int, float], int]:
-        return self._ids_of_time_series
+    def get_reconstructed_series_by_id(self, series_id: int) -> str:
+        """Return name or path for given `series_id` if series these are identified by their number.
+        Use this only if series were added via `reconstruct_time_series`"""
+        if series_id < 0 or series_id > self._id_count:
+            log_error_and_raise(TimeSeriesException(self._ERR_UNREGISTERED_SERIES.format(series_id)))
+        return self._series_by_id[series_id][Entry.NAME]

fameio/source/time.py

@@ -5,7 +5,7 @@
 import datetime as dt
 import math
 import re
-from enum import Enum
+from enum import Enum, auto
 from typing import Union
 
 from fameio.source.logs import log_error_and_raise
@@ -25,13 +25,13 @@ class ConversionException(Exception):
 class TimeUnit(Enum):
     """Time units defined in FAME"""
 
-    SECONDS = 0
-    MINUTES = 1
-    HOURS = 2
-    DAYS = 3
-    WEEKS = 4
-    MONTHS = 5
-    YEARS = 6
+    SECONDS = auto()
+    MINUTES = auto()
+    HOURS = auto()
+    DAYS = auto()
+    WEEKS = auto()
+    MONTHS = auto()
+    YEARS = auto()
 
 
 class Constants:

fameio/source/tools.py

@@ -1,8 +1,8 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
-
-from typing import Any, Dict
+from pathlib import Path
+from typing import Any, Dict, Union
 
 
 def keys_to_lower(dictionary: Dict[str, Any]) -> Dict[str, Any]:
@@ -16,3 +16,14 @@ def ensure_is_list(value: Any) -> list:
         return value
     else:
         return [value]
+
+
+def ensure_path_exists(path: Union[Path, str]):
+    """Creates a specified path if not already existent"""
+    Path(path).mkdir(parents=True, exist_ok=True)
+
+
+def clean_up_file_name(name: str) -> str:
+    """Returns given `name` with replacements defined in `replace_map`"""
+    replace_map = {" ": "_", ":": "_", "/": "-"}
+    return name.translate(str.maketrans(replace_map))

fameio/source/validator.py

@@ -2,15 +2,17 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import logging as log
+import math
 from collections import Counter
 from typing import Any, Dict, List
 
-from fameio.source.logs import log_error_and_raise
+from fameio.source import PathResolver
+from fameio.source.logs import log_error_and_raise, log
 from fameio.source.scenario import Agent, Attribute, Contract, Scenario
 from fameio.source.schema.agenttype import AgentType
 from fameio.source.schema.attribute import AttributeSpecs, AttributeType
 from fameio.source.schema.schema import Schema
+from fameio.source.series import TimeSeriesManager, TimeSeriesException
 from fameio.source.time import FameTime
 
 
@@ -36,6 +38,77 @@ class SchemaValidator:
     _DEFAULT_IGNORED = "Optional Attribute: '{}': not specified - provided Default ignored for optional Attributes."
     _OPTIONAL_MISSING = "Optional Attribute: '{}': not specified."
     _IS_NO_LIST = "Attribute '{}' is list but assigned value '{}' is not a list."
+    _TIME_SERIES_INVALID = "Timeseries at '{}' is invalid."
+    _MISSING_CONTRACTS_FOR_AGENTS = "No contracts defined for Agent '{}' of type '{}'"
+
+    @staticmethod
+    def validate_scenario_and_timeseries(
+        scenario: Scenario, path_resolver: PathResolver = PathResolver()
+    ) -> TimeSeriesManager:
+        """
+        Validates the given `scenario` and its timeseries using given `path_resolver`
+        Raises an exception if schema requirements are not met or timeseries data are erroneous.
+
+        Args:
+            scenario: to be validated against the encompassed schema
+            path_resolver: to resolve paths of timeseries
+
+        Returns:
+            a new TimeSeriesManager initialised with validated time series from scenario
+        Raises:
+            ValidationException: if an error in the scenario or in timeseries is spotted
+        """
+        schema = scenario.schema
+        agents = scenario.agents
+        timeseries_manager = TimeSeriesManager(path_resolver)
+
+        SchemaValidator.ensure_unique_agent_ids(agents)
+        for agent in agents:
+            SchemaValidator.ensure_agent_and_timeseries_are_valid(agent, schema, timeseries_manager)
+
+        agent_types_by_id = {agent.id: agent.type_name for agent in agents}
+        for contract in scenario.contracts:
+            SchemaValidator.ensure_is_valid_contract(contract, schema, agent_types_by_id)
+
+        return timeseries_manager
+
+    @staticmethod
+    def ensure_unique_agent_ids(agents: List[Agent]) -> None:
+        """Raises exception if any id for given `agents` is not unique"""
+        list_of_ids = [agent.id for agent in agents]
+        non_unique_ids = [agent_id for agent_id, count in Counter(list_of_ids).items() if count > 1]
+        if non_unique_ids:
+            log_error_and_raise(ValidationException(SchemaValidator._AGENT_ID_NOT_UNIQUE.format(non_unique_ids)))
+
+    @staticmethod
+    def ensure_agent_and_timeseries_are_valid(agent: Agent, schema: Schema, timeseries_manager: TimeSeriesManager):
+        """Validates given `agent` against `schema` plus loads and validates its timeseries"""
+        SchemaValidator.ensure_agent_type_in_schema(agent, schema)
+        SchemaValidator.ensure_is_valid_agent(agent, schema)
+        SchemaValidator.load_and_validate_timeseries(agent, schema, timeseries_manager)
+
+    @staticmethod
+    def ensure_agent_type_in_schema(agent: Agent, schema: Schema) -> None:
+        """Raises exception if type for given `agent` is not specified in given `schema`"""
+        if agent.type_name not in schema.agent_types:
+            log_error_and_raise(ValidationException(SchemaValidator._AGENT_TYPE_UNKNOWN.format(agent.type_name)))
+
+    @staticmethod
+    def ensure_is_valid_agent(agent: Agent, schema: Schema) -> None:
+        """Raises an exception if given `agent` does not meet the specified `schema` requirements"""
+        scenario_attributes = agent.attributes
+        schema_attributes = SchemaValidator._get_agent(schema, agent.type_name).attributes
+        SchemaValidator._ensure_mandatory_present(scenario_attributes, schema_attributes)
+        SchemaValidator._ensure_attributes_exist(scenario_attributes, schema_attributes)
+        SchemaValidator._ensure_value_and_type_match(scenario_attributes, schema_attributes)
+
+    @staticmethod
+    def _get_agent(schema: Schema, name: str) -> AgentType:
+        """Returns agent specified by `name` or raises Exception if this agent is not present in given `schema`"""
+        if name in schema.agent_types:
+            return schema.agent_types[name]
+        else:
+            log_error_and_raise(ValidationException(SchemaValidator._AGENT_TYPE_UNKNOWN.format(name)))
 
     @staticmethod
     def _ensure_mandatory_present(attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs]) -> None:
@@ -47,12 +120,14 @@ class SchemaValidator:
             if name not in attributes:
                 if specification.is_mandatory:
                     if not specification.has_default_value:
-                        log_error_and_raise(ValidationException(SchemaValidator._ATTRIBUTE_MISSING.format(name)))
+                        log_error_and_raise(
+                            ValidationException(SchemaValidator._ATTRIBUTE_MISSING.format(specification.full_name))
+                        )
                 else:
                     if specification.has_default_value:
-                        log.warning(SchemaValidator._DEFAULT_IGNORED.format(name))
+                        log().warning(SchemaValidator._DEFAULT_IGNORED.format(specification.full_name))
                     else:
-                        log.info(SchemaValidator._OPTIONAL_MISSING.format(name))
+                        log().info(SchemaValidator._OPTIONAL_MISSING.format(specification.full_name))
             if name in attributes and specification.has_nested_attributes:
                 attribute = attributes[name]
                 if specification.is_list:
@@ -61,23 +136,6 @@ class SchemaValidator:
                 else:
                     SchemaValidator._ensure_mandatory_present(attribute.nested, specification.nested_attributes)
 
-    @staticmethod
-    def _get_agent(schema: Schema, name: str) -> AgentType:
-        """Returns agent specified by `name` or raises Exception if this agent is not present in given `schema`"""
-        if name in schema.agent_types:
-            return schema.agent_types[name]
-        else:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_TYPE_UNKNOWN.format(name)))
-
-    @staticmethod
-    def ensure_is_valid_agent(agent: Agent, schema: Schema) -> None:
-        """Raises an exception if given `agent` does not meet the specified `schema` requirements"""
-        scenario_attributes = agent.attributes
-        schema_attributes = SchemaValidator._get_agent(schema, agent.type_name).attributes
-        SchemaValidator._ensure_mandatory_present(scenario_attributes, schema_attributes)
-        SchemaValidator._ensure_attributes_exist(scenario_attributes, schema_attributes)
-        SchemaValidator._ensure_value_matches_type(scenario_attributes, schema_attributes)
-
     @staticmethod
     def _ensure_attributes_exist(attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs]) -> None:
         """Raises exception any entry of given `attributes` has no corresponding type `specification`"""
@@ -93,7 +151,9 @@ class SchemaValidator:
                     SchemaValidator._ensure_attributes_exist(entry, specification.nested_attributes)
 
     @staticmethod
-    def _ensure_value_matches_type(attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs]) -> None:
+    def _ensure_value_and_type_match(
+        attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs]
+    ) -> None:
         """Raises exception if in given list of `attributes` its value does not match associated type `specification`"""
         for name, attribute in attributes.items():
             specification = specifications[name]
@@ -104,14 +164,13 @@ class SchemaValidator:
                     message = SchemaValidator._INCOMPATIBLE.format(value, type_spec, specification.full_name)
                     log_error_and_raise(ValidationException(message))
                 if not SchemaValidator._is_allowed_value(specification, value):
-                    log_error_and_raise(
-                        ValidationException(SchemaValidator._DISALLOWED.format(value, specification.full_name))
-                    )
+                    message = SchemaValidator._DISALLOWED.format(value, specification.full_name)
+                    log_error_and_raise(ValidationException(message))
             if attribute.has_nested:
-                SchemaValidator._ensure_value_matches_type(attribute.nested, specification.nested_attributes)
+                SchemaValidator._ensure_value_and_type_match(attribute.nested, specification.nested_attributes)
             if attribute.has_nested_list:
                 for entry in attribute.nested_list:
-                    SchemaValidator._ensure_value_matches_type(entry, specification.nested_attributes)
+                    SchemaValidator._ensure_value_and_type_match(entry, specification.nested_attributes)
 
     @staticmethod
     def _is_compatible(specification: AttributeSpecs, value_or_values: Any) -> bool:
@@ -120,7 +179,7 @@ class SchemaValidator:
         attribute_type = specification.attr_type
         if specification.is_list:
             if not is_list:
-                log.warning(SchemaValidator._IS_NO_LIST.format(specification.full_name, value_or_values))
+                log().warning(SchemaValidator._IS_NO_LIST.format(specification.full_name, value_or_values))
                 return SchemaValidator._is_compatible_value(attribute_type, value_or_values)
             for value in value_or_values:
                 if not SchemaValidator._is_compatible_value(attribute_type, value):
@@ -131,7 +190,7 @@ class SchemaValidator:
 
     @staticmethod
     def _is_compatible_value(attribute_type: AttributeType, value) -> bool:
-        """Returns True if given single value is compatible to specified `attribute_type`"""
+        """Returns True if given single value is compatible to specified `attribute_type` and is not a NaN float"""
         if attribute_type is AttributeType.INTEGER:
             if isinstance(value, int):
                 return -2147483648 < value < 2147483647
@@ -139,13 +198,13 @@ class SchemaValidator:
         if attribute_type is AttributeType.LONG:
             return isinstance(value, int)
         elif attribute_type is AttributeType.DOUBLE:
-            return isinstance(value, (int, float))
+            return isinstance(value, (int, float)) and not math.isnan(value)
         elif attribute_type in (AttributeType.ENUM, AttributeType.STRING):
             return isinstance(value, str)
         elif attribute_type is AttributeType.TIME_STAMP:
             return FameTime.is_fame_time_compatible(value)
         elif attribute_type is AttributeType.TIME_SERIES:
-            return isinstance(value, (str, int, float))
+            return isinstance(value, (str, int)) or (isinstance(value, float) and not math.isnan(value))
         else:
             log_error_and_raise(ValidationException(SchemaValidator._TYPE_NOT_IMPLEMENTED.format(attribute_type)))
 
@@ -157,6 +216,44 @@ class SchemaValidator:
         else:
             return value in attribute.values
 
+    @staticmethod
+    def load_and_validate_timeseries(agent: Agent, schema: Schema, timeseries_manager: TimeSeriesManager) -> None:
+        """
+        Loads all timeseries specified in given `schema` of given `agent` into given `timeseries_manager`
+
+        Args:
+            agent: definition in scenario
+            schema: schema encompassed in scenario
+            timeseries_manager: to be filled with timeseries
+
+        Raises:
+            ValidationException: if timeseries is not found, ill-formatted or invalid
+        """
+        scenario_attributes = agent.attributes
+        schema_attributes = SchemaValidator._get_agent(schema, agent.type_name).attributes
+        SchemaValidator._ensure_valid_timeseries(scenario_attributes, schema_attributes, timeseries_manager)
+
+    @staticmethod
+    def _ensure_valid_timeseries(
+        attributes: Dict[str, Attribute], specifications: Dict[str, AttributeSpecs], manager: TimeSeriesManager
+    ) -> None:
+        """Recursively searches for time_series in agent attributes and registers them at given `manager`"""
+        for name, attribute in attributes.items():
+            specification = specifications[name]
+            if attribute.has_value:
+                attribute_type = specification.attr_type
+                if attribute_type is AttributeType.TIME_SERIES:
+                    try:
+                        manager.register_and_validate(attribute.value)
+                    except TimeSeriesException as e:
+                        message = SchemaValidator._TIME_SERIES_INVALID.format(specification.full_name)
+                        log_error_and_raise(ValidationException(message, e))
+            if attribute.has_nested:
+                SchemaValidator._ensure_valid_timeseries(attribute.nested, specification.nested_attributes, manager)
+            if attribute.has_nested_list:
+                for entry in attribute.nested_list:
+                    SchemaValidator._ensure_valid_timeseries(entry, specification.nested_attributes, manager)
+
     @staticmethod
     def ensure_is_valid_contract(contract: Contract, schema: Schema, agent_types_by_id: Dict[int, str]) -> None:
         """Raises exception if given `contract` does not meet the `schema`'s requirements, using `agent_types_by_id`"""
@@ -174,30 +271,13 @@ class SchemaValidator:
             log_error_and_raise(ValidationException(SchemaValidator._PRODUCT_MISSING.format(product, sender_type_name)))
 
     @staticmethod
-    def ensure_unique_agent_ids(agents: List[Agent]) -> None:
-        """Raises exception if any id for given `agents` is not unique"""
-        list_of_ids = [agent.id for agent in agents]
-        non_unique_ids = [agent_id for agent_id, count in Counter(list_of_ids).items() if count > 1]
-        if non_unique_ids:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_ID_NOT_UNIQUE.format(non_unique_ids)))
+    def check_agents_have_contracts(scenario: Scenario) -> None:
+        """Raises warning for each agent without any assigned contract"""
+        senders = [contract.sender_id for contract in scenario.contracts]
+        receivers = [contract.receiver_id for contract in scenario.contracts]
+        active_agents = set(senders + receivers)
+        inactive_agents = {agent.id: agent.type_name for agent in scenario.agents if agent.id not in active_agents}
 
-    @staticmethod
-    def ensure_agent_type_in_schema(agent: Agent, schema: Schema) -> None:
-        """Raises exception if type for given `agent` is not specified in given `schema`"""
-        if agent.type_name not in schema.agent_types:
-            log_error_and_raise(ValidationException(SchemaValidator._AGENT_TYPE_UNKNOWN.format(agent.type_name)))
-
-    @staticmethod
-    def ensure_is_valid_scenario(scenario: Scenario) -> None:
-        """Raises exception if given `scenario` does not meet its own schema requirements"""
-        schema = scenario.schema
-        agents = scenario.agents
-
-        SchemaValidator.ensure_unique_agent_ids(agents)
-        for agent in agents:
-            SchemaValidator.ensure_agent_type_in_schema(agent, schema)
-            SchemaValidator.ensure_is_valid_agent(agent, schema)
-
-        agent_types_by_id = {agent.id: agent.type_name for agent in agents}
-        for contract in scenario.contracts:
-            SchemaValidator.ensure_is_valid_contract(contract, schema, agent_types_by_id)
+        if inactive_agents:
+            for agent_id, agent_name in inactive_agents.items():
+                log().warning(SchemaValidator._MISSING_CONTRACTS_FOR_AGENTS.format(agent_id, agent_name))