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

fameio/input/scenario/generalproperties.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
@@ -8,7 +8,7 @@ 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
+from .exception import get_or_raise
 
 
 class GeneralProperties:
@@ -39,9 +39,20 @@ class GeneralProperties:
 
     @classmethod
     def from_dict(cls, definitions: dict) -> GeneralProperties:
-        """Parse general properties from provided `definitions`"""
+        """
+        Parse general properties from provided `definitions`
+
+        Args:
+            definitions: dictionary representation of general properties
+
+        Returns:
+            new GeneralProperties
+
+        Raises:
+            ScenarioError: if definitions are incomplete or erroneous, logged on level "ERROR"
+        """
         definitions = keys_to_lower(definitions)
-        run_id = get_or_default(definitions, GeneralProperties.KEY_RUN, 1)
+        run_id = definitions.get(GeneralProperties.KEY_RUN, 1)
 
         simulation_definition = keys_to_lower(
             get_or_raise(
@@ -64,12 +75,12 @@ class GeneralProperties:
                 GeneralProperties._ERR_MISSING_KEY,
             )
         )
-        random_seed = get_or_default(simulation_definition, GeneralProperties.KEY_SEED, 1)
+        random_seed = simulation_definition.get(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: dict = {self.KEY_RUN: self._run_id}
         simulation_dict = {
             self.KEY_START: self.simulation_start_time,
             self.KEY_STOP: self.simulation_stop_time,

fameio/input/scenario/scenario.py

@@ -1,19 +1,20 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import Final
+from typing import Final, Any
 
+from fameio.input import SchemaError
 from fameio.input.metadata import Metadata
+from fameio.input.scenario.agent import Agent
+from fameio.input.scenario.contract import Contract
+from fameio.input.scenario.exception import get_or_raise, log_scenario_error
+from fameio.input.scenario.fameiofactory import FameIOFactory
+from fameio.input.scenario.generalproperties import GeneralProperties
+from fameio.input.scenario.stringset import StringSet
 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(Metadata):
@@ -26,42 +27,124 @@ class Scenario(Metadata):
     KEY_STRING_SETS: Final[str] = "StringSets".lower()
 
     _MISSING_KEY = "Scenario definition misses required key '{}'."
+    _ERR_SCHEMA = "Could not create scenario: Definition of Schema has errors."
+    _ERR_STRING_SET = "Could not create scenario: Definition of StringSet '{}' has errors."
+    _ERR_MULTI_CONTRACT = "Could not create scenario: Definition of Contracts has errors: {}"
+    _ERR_CONTRACT = "Could not create scenario: Definition of Contract has errors: {}"
 
     def __init__(self, schema: Schema, general_props: GeneralProperties) -> None:
         super().__init__()
         self._schema = schema
         self._general_props = general_props
-        self._string_sets = {}
-        self._agents = []
-        self._contracts = []
+        self._string_sets: dict[str, StringSet] = {}
+        self._agents: list[Agent] = []
+        self._contracts: list[Contract] = []
 
     @classmethod
-    def from_dict(cls, definitions: dict, factory=FameIOFactory()) -> Scenario:
-        """Parse scenario from provided `definitions` using given `factory`"""
-        definitions = keys_to_lower(definitions)
+    def from_dict(cls, definitions: dict, factory: FameIOFactory = FameIOFactory()) -> Scenario:
+        """
+        Parse scenario from provided `definitions` using given `factory`
 
-        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)
-        )
-        scenario = cls(schema, general_props)
-        scenario._extract_metadata(definitions)
+        Args:
+            definitions: dictionary representation of scenario
+            factory: helper class with static helpers to instantiate scenario components
 
-        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))
+        Returns:
+            new Scenario
 
-        for agent_definition in get_or_default(definitions, Scenario.KEY_AGENTS, []):
-            scenario.add_agent(factory.new_agent_from_dict(agent_definition))
+        Raises:
+            ScenarioError: if scenario definitions are incomplete or erroneous, logged with level "ERROR"
+        """
+        definitions = keys_to_lower(definitions)
 
-        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))
+        schema = Scenario._extract_schema(definitions, factory)
+        general_properties_definition = get_or_raise(definitions, Scenario.KEY_GENERAL, Scenario._MISSING_KEY)
+        general_properties = factory.new_general_properties_from_dict(general_properties_definition)
+        scenario = cls(schema, general_properties)
+        scenario._extract_metadata(definitions)
 
+        scenario._string_sets = Scenario._extract_string_sets(definitions, factory)
+        scenario._agents = [
+            factory.new_agent_from_dict(agent_definition)
+            for agent_definition in definitions.get(Scenario.KEY_AGENTS, [])
+        ]
+        scenario._contracts = Scenario._extract_contracts(definitions, factory)
         return scenario
 
+    @staticmethod
+    def _extract_schema(definitions: dict, factory: FameIOFactory) -> Schema:
+        """
+        Extract schema from given definitions and create Schema from it
+
+        Args:
+            definitions: dictionary representation of scenario
+            factory: helper class with static helpers to instantiate scenario components
+
+        Returns:
+            new schema
+
+        Raises:
+            ScenarioError: if schema definitions are missing, incomplete, or erroneous; logged on level "ERROR"
+        """
+        schema_definition = get_or_raise(definitions, Scenario.KEY_SCHEMA, Scenario._MISSING_KEY)
+        try:
+            return factory.new_schema_from_dict(schema_definition)
+        except SchemaError as e:
+            raise log_scenario_error(Scenario._ERR_SCHEMA) from e
+
+    @staticmethod
+    def _extract_string_sets(definitions: dict, factory: FameIOFactory) -> dict[str, StringSet]:
+        """
+        Extract string sets from given definitions and create dictionary from it
+
+        Args:
+            definitions: dictionary representation of scenario
+            factory: helper class with static helpers to instantiate scenario components
+
+        Returns:
+            dictionary of string set names associated with their corresponding string set
+
+        Raises:
+            ScenarioError: if string set definitions are incomplete or erroneous; logged on level "ERROR"
+        """
+        string_sets = {}
+        for name, string_set_definition in definitions.get(Scenario.KEY_STRING_SETS, {}).items():
+            try:
+                string_sets[name] = factory.new_string_set_from_dict(string_set_definition)
+            except StringSet.StringSetError as e:
+                raise log_scenario_error(Scenario._ERR_STRING_SET.format(name)) from e
+        return string_sets
+
+    @staticmethod
+    def _extract_contracts(definitions: dict, factory: FameIOFactory) -> list[Contract]:
+        """
+        Extract contracts from given definitions
+
+        Args:
+            definitions: dictionary representation of scenario
+            factory: helper class with static helpers to instantiate scenario components
+
+        Returns:
+            list of all created one-to-one contracts
+
+        Raises:
+            ScenarioError: if contract definitions are incomplete or erroneous; logged on level "ERROR"
+        """
+        contracts = []
+        for multi_contract_definition in definitions.get(Scenario.KEY_CONTRACTS, []):
+            try:
+                for single_contract_definition in Contract.split_contract_definitions(multi_contract_definition):
+                    try:
+                        contracts.append(factory.new_contract_from_dict(single_contract_definition))
+                    except Contract.ContractError as e:
+                        raise log_scenario_error(Scenario._ERR_CONTRACT.format(single_contract_definition)) from e
+            except Contract.ContractError as e:
+                raise log_scenario_error(Scenario._ERR_MULTI_CONTRACT.format(multi_contract_definition)) from e
+        return contracts
+
     def _to_dict(self) -> dict:
         """Serializes the scenario content to a dict"""
-        result = {
+        result: dict[str, Any] = {
             Scenario.KEY_GENERAL: self.general_properties.to_dict(),
             Scenario.KEY_SCHEMA: self.schema.to_dict(),
         }

fameio/input/scenario/stringset.py

@@ -1,38 +1,57 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import Union, Final
+from typing import Final, Any, Union
 
+from fameio.input import InputError
 from fameio.input.metadata import Metadata, MetadataComponent, ValueContainer
+from fameio.logs import log_error
 from fameio.tools import keys_to_lower
-from .exception import log_and_raise
 
 
 class StringSet(Metadata):
     """Hosts a StringSet in the given format"""
 
+    class StringSetError(InputError):
+        """An error that occurred while parsing a StringSet definition"""
+
     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 {}."
+    _ERR_VALUE_DEFINITION = "StringSet could not be parsed."
 
-    def __init__(self, definitions=None):
+    def __init__(self, definitions: dict[str, Any] | list[Any] | None = None):
         super().__init__(definitions)
         self._value_container: ValueContainer = ValueContainer(definitions)
 
     @classmethod
     def from_dict(cls, definition: StringSetType) -> StringSet:
-        """Returns StringSet initialised from `definition`"""
+        """
+        Returns StringSet initialised from `definition`
+
+        Args:
+            definition: dictionary representation of string set
+
+        Returns:
+            new StringSet
+
+        Raises:
+            StringSetError: if definitions are incomplete or erroneous, logged on level "ERROR"
+        """
         string_set = cls(definition)
         definition = keys_to_lower(definition)
         if cls.KEY_VALUES in definition:
-            string_set._value_container = ValueContainer(definition[cls.KEY_VALUES])
+            try:
+                string_set._value_container = ValueContainer(definition[cls.KEY_VALUES])
+            except ValueContainer.ParseError as e:
+                raise log_error(StringSet.StringSetError(StringSet._ERR_VALUE_DEFINITION)) from e
         else:
-            log_and_raise(cls._ERR_KEY_MISSING.format(cls.KEY_VALUES, definition))
+            raise log_error(StringSet.StringSetError(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]]]]:
@@ -43,6 +62,6 @@ class StringSet(Metadata):
         """Returns values and their associated MetadataComponent"""
         return self._value_container.values
 
-    def is_in_set(self, key: str) -> bool:
+    def is_in_set(self, key: Any) -> bool:
         """Returns True if `key` is a valid name in this StringSet"""
         return self._value_container.has_value(key)

fameio/input/schema/agenttype.py

@@ -32,7 +32,10 @@ class AgentType(Metadata):
         Initialise a new AgentType
 
         Args:
-            name: name of the AgenType - must not be None, empty or only whitespaces
+            name: name of the AgenType
+
+        Raises:
+            SchemaError: if name is None, empty, or only whitespaces, logged with level "ERROR"
         """
         super().__init__()
         if not name or name.isspace():
@@ -53,6 +56,9 @@ class AgentType(Metadata):
 
         Returns:
             a new instance of AgentType
+
+        Raises:
+            SchemaError: if definitions are invalid, logged with level "ERROR"
         """
         agent_type = cls(name)
         agent_type._extract_metadata(definitions)
@@ -83,7 +89,20 @@ class AgentType(Metadata):
 
     @staticmethod
     def _read_values(section: str, agent_type: str, values: Any) -> ValueContainer:
-        """Returns ValueContainer for `section` of in specifications of `agent_type` extracted from given `values`"""
+        """
+        Returns ValueContainer for `section` of in specifications of `agent_type` extracted from given `values`
+
+        Args:
+            section: key of the section that contains the values
+            agent_type: name of the agent type that the values are associated with
+            values: list or dict with value definitions
+
+        Returns:
+            container for all the extracted values
+
+        Raises:
+            SchemaError: if the values are ill-formatted, logged with level "ERROR"
+        """
         try:
             data = ValueContainer(values)
         except InputError as e:

fameio/input/schema/attribute.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from enum import Enum, auto
 from pathlib import Path
-from typing import Any, Optional, Final, Union
+from typing import Any, Final
 
 from fameio.input import SchemaError
 from fameio.input.metadata import Metadata, ValueContainer
@@ -28,7 +28,7 @@ class AttributeType(Enum):
     TIME_SERIES = auto()
     BLOCK = auto()
 
-    def convert_string_to_type(self, value: str) -> Union[int, float, str]:
+    def convert_string_to_type(self, value: str) -> int | float | str:
         """
         Converts a given string to this AttributeType's data format
 
@@ -75,6 +75,7 @@ class AttributeSpecs(Metadata):
     _MISSING_TYPE = "'AttributeType' not declare for Attribute '{}'."
     _INVALID_TYPE = "'{}' is not a valid type for an Attribute."
     _DEFAULT_NOT_LIST = "Attribute is list, but provided Default '{}' is not a list."
+    _DEFAULT_NOT_SIMPLE = "Only a simple Default value is allowed for non-list attributes, but was '{}'"
     _INCOMPATIBLE = "Value '{}' in section '{}' can not be converted to AttributeType '{}'."
     _DEFAULT_DISALLOWED = "Default '{}' is not an allowed value."
     _SERIES_LIST_DISALLOWED = "Attribute '{}' of type TIME_SERIES cannot be a list."
@@ -82,13 +83,22 @@ class AttributeSpecs(Metadata):
     _NAME_DISALLOWED = f"Attribute name must not be empty and none of: {_DISALLOWED_NAMES}"
 
     def __init__(self, name: str, definition: dict):
-        """Loads Attribute from given `definition`"""
+        """
+        Loads Attribute from given `definition`
+
+        Args:
+            name: of attribute type
+            definition: of attribute type
+
+        Raises:
+            SchemaError: if attribute type is not properly defined, logged with level "ERROR"
+        """
         super().__init__(definition)
         self._assert_is_allowed_name(name)
         self._full_name = name
 
         if not definition:
-            raise SchemaError(AttributeSpecs._EMPTY_DEFINITION.format(name))
+            raise log_error(SchemaError(AttributeSpecs._EMPTY_DEFINITION.format(name)))
         definition = keys_to_lower(definition)
 
         self._is_mandatory = self._get_is_mandatory(definition, name)
@@ -96,7 +106,7 @@ class AttributeSpecs(Metadata):
         self._attr_type = self._get_type(definition, name)
 
         if self._attr_type == AttributeType.TIME_SERIES and self._is_list:
-            raise SchemaError(AttributeSpecs._SERIES_LIST_DISALLOWED.format(name))
+            raise log_error(SchemaError(AttributeSpecs._SERIES_LIST_DISALLOWED.format(name)))
 
         self._allowed_values = self._get_allowed_values(definition)
         self._default_value = self._get_default_value(definition)
@@ -105,14 +115,22 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _assert_is_allowed_name(full_name: str) -> None:
-        """Raises SchemaError if provided name is not allowed for Attributes"""
+        """
+        Raises SchemaError if provided name is not allowed for Attributes
+
+        Args:
+            full_name: to be checked if it can serve as name for an attribute
+
+        Raises:
+            SchemaError: if name is not allowed, logged with level "ERROR"
+        """
         if full_name is None:
-            raise SchemaError(AttributeSpecs._NAME_DISALLOWED)
+            raise log_error(SchemaError(AttributeSpecs._NAME_DISALLOWED))
         short_name = full_name.split(AttributeSpecs._SEPARATOR)[-1]
         if len(short_name) == 0 or short_name.isspace():
-            raise SchemaError(AttributeSpecs._NAME_DISALLOWED)
+            raise log_error(SchemaError(AttributeSpecs._NAME_DISALLOWED))
         if short_name.lower() in AttributeSpecs._DISALLOWED_NAMES:
-            raise SchemaError(AttributeSpecs._NAME_DISALLOWED)
+            raise log_error(SchemaError(AttributeSpecs._NAME_DISALLOWED))
 
     @staticmethod
     def _get_is_mandatory(definition: dict, name: str) -> bool:
@@ -132,13 +150,25 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _get_type(definition: dict, name: str) -> AttributeType:
-        """Returns `AttributeType` from given definition; Raises an exception if no proper type can be extracted"""
+        """
+        Returns `AttributeType` from given definition
+
+        Args:
+            definition: of the attribute
+            name: of the attribute
+
+        Returns:
+            type of attribute
+
+        Raises:
+            SchemaError: if no proper type can be extracted, logged with level "ERROR"
+        """
         if AttributeSpecs.KEY_TYPE in definition:
             type_name = definition[AttributeSpecs.KEY_TYPE]
             try:
                 return AttributeType[type_name.upper()]
             except KeyError as e:
-                raise SchemaError(AttributeSpecs._INVALID_TYPE.format(type_name)) from e
+                raise log_error(SchemaError(AttributeSpecs._INVALID_TYPE.format(type_name))) from e
         raise log_error(SchemaError(AttributeSpecs._MISSING_TYPE.format(name)))
 
     def _get_allowed_values(self, definition: dict) -> ValueContainer:
@@ -150,7 +180,7 @@ class AttributeSpecs(Metadata):
                 allowed_values = self._read_values(value_definition)
         return allowed_values
 
-    def _read_values(self, definition: [dict, list]) -> ValueContainer:
+    def _read_values(self, definition: dict | list) -> ValueContainer:
         """
         Returns accepted values mapped to their additional metadata specifications extracted from given `definition`
         Accepts lists of accepted values or dictionaries with (optional) metadata assigned to each value
@@ -160,6 +190,9 @@ class AttributeSpecs(Metadata):
 
         Returns:
             Mapping of acceptable values to their associated Metadata
+
+        Raises:
+            SchemaError: if values could not be parsed, logged with level "ERROR"
         """
         try:
             value_container = ValueContainer(definition)
@@ -167,16 +200,28 @@ class AttributeSpecs(Metadata):
                 self._convert_to_data_type(value, self.KEY_VALUES)
             return value_container
         except ValueContainer.ParseError as e:
-            raise SchemaError(AttributeSpecs._VALUES_ILL_FORMAT.format(definition)) from e
+            raise log_error(SchemaError(AttributeSpecs._VALUES_ILL_FORMAT.format(definition))) from e
+
+    def _convert_to_data_type(self, value: str, section: str) -> int | float | str:
+        """
+        Returns a given single `value` in `section` converted to this Attribute's data type
+
+        Args:
+            value: to be converted
+            section: that contains the value
 
-    def _convert_to_data_type(self, value: str, section: str) -> Union[int, float, str]:
-        """Returns a given single `value` in `section` converted to this Attribute's data type"""
+        Returns:
+            value with type matching this attribute type
+
+        Raises:
+            SchemaError: if value does not match this type of attribute, logged with level "ERROR"
+        """
         try:
             return self._attr_type.convert_string_to_type(value)
         except ValueError as e:
-            raise SchemaError(AttributeSpecs._INCOMPATIBLE.format(value, section, self._attr_type)) from e
+            raise log_error(SchemaError(AttributeSpecs._INCOMPATIBLE.format(value, section, self._attr_type))) from e
 
-    def _get_default_value(self, definition: dict) -> Optional[Union[int, float, str, list]]:
+    def _get_default_value(self, definition: dict) -> int | float | str | list | None:
         """Returns default value(s) from given definitions, or None if no default is specified"""
         if AttributeSpecs.KEY_DEFAULT in definition:
             provided_value = definition[AttributeSpecs.KEY_DEFAULT]
@@ -186,15 +231,39 @@ class AttributeSpecs(Metadata):
         return None
 
     def _convert_list(self, values) -> list:
-        """Converts all entries in given `values` list to this attribute data type and returns this new list"""
+        """
+        Converts all entries in given `values` list to this attribute data type and returns this new list
+
+        Args:
+            values: to be converted to a list of default values
+
+        Returns:
+            default values
+
+        Raises:
+            SchemaError: if provided default is not a list, logged with level "ERROR"
+        """
         if isinstance(values, list):
             return [self._convert_and_test(item) for item in values]
-        raise SchemaError(AttributeSpecs._DEFAULT_NOT_LIST.format(values))
+        raise log_error(SchemaError(AttributeSpecs._DEFAULT_NOT_LIST.format(values)))
 
     def _convert_and_test(self, value: str):
-        """Converts a given single `value` to this Attribute's data type and tests if the value is allowed"""
+        """
+        Converts a given single `value` to this Attribute's data type and tests if the value is allowed
+
+        Args:
+            value: to be converted and tested
+
+        Returns:
+            the value converted to the data type matching this attribute type
+
+        Raises:
+            SchemaError: if the provided default could not be converted or is not allowed, logged with level "ERROR"
+        """
+        if isinstance(value, (list, dict)):
+            raise log_error(SchemaError(self._DEFAULT_NOT_SIMPLE.format(value)))
         if self.has_value_restrictions and (not self._allowed_values.has_value(value)):
-            raise SchemaError(AttributeSpecs._DEFAULT_DISALLOWED.format(value))
+            raise log_error(SchemaError(AttributeSpecs._DEFAULT_DISALLOWED.format(value)))
         return self._convert_to_data_type(value, self.KEY_DEFAULT)
 
     @staticmethod
@@ -248,7 +317,7 @@ class AttributeSpecs(Metadata):
         return self._default_value is not None
 
     @property
-    def default_value(self) -> Optional[Any]:
+    def default_value(self) -> Any | None:
         """Return the default value of this attribute, or None if no default is specified"""
         return self._default_value
 

fameio/input/schema/java_packages.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
@@ -6,7 +6,7 @@ from __future__ import annotations
 from typing import Final
 
 from fameio.input import SchemaError
-from fameio.logs import log_error_and_raise, log
+from fameio.logs import log, log_error
 from fameio.tools import keys_to_lower
 
 
@@ -21,7 +21,7 @@ class JavaPackages:
     _INFO_MISSING_DATA_ITEMS = "`DataItems` not specified: Key was missing or list was empty."
     _ERR_MISSING_PORTABLES = "JavaPackages require non-empty list for `Portables`. Key was missing or list was empty."
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._agents: list[str] = []
         self._data_items: list[str] = []
         self._portables: list[str] = []
@@ -36,6 +36,9 @@ class JavaPackages:
 
         Returns:
             new instance of JavaPackages
+
+        Raises:
+            SchemaError: if definitions are incomplete or erroneous, logged on level "ERROR"
         """
         java_packages = cls()
         definitions = keys_to_lower(definitions)
@@ -45,11 +48,11 @@ class JavaPackages:
         java_packages._portables = definitions.get(JavaPackages.KEY_PORTABLE, [])
 
         if not java_packages._agents:
-            log_error_and_raise(SchemaError(JavaPackages._ERR_MISSING_AGENTS))
+            raise log_error(SchemaError(JavaPackages._ERR_MISSING_AGENTS))
         if not java_packages._data_items:
             log().info(JavaPackages._INFO_MISSING_DATA_ITEMS)
         if not java_packages._portables:
-            log_error_and_raise(SchemaError(JavaPackages._ERR_MISSING_PORTABLES))
+            raise log_error(SchemaError(JavaPackages._ERR_MISSING_PORTABLES))
 
         return java_packages