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

fameio/input/scenario/attribute.py

@@ -9,11 +9,12 @@ from typing import Any, NamedTuple, Final
 
 from fameio.input.metadata import Metadata, MetadataComponent
 from fameio.tools import keys_to_lower
-from .exception import log_and_raise
+from .exception import log_scenario_error
+from ...logs import log_error
 
 
 class Attribute(Metadata):
-    """An Attribute of an agent in a scenario"""
+    """An Attribute of an agent in a scenario."""
 
     KEY_VALUE: Final[str] = "Value".lower()
     KEY_VALUES: Final[str] = "Values".lower()
@@ -21,37 +22,49 @@ class Attribute(Metadata):
     NAME_STRING_SEPARATOR: Final[str] = "."
 
     class __ValueMeta(NamedTuple):
-        """NamedTuple for a primitive value associated with Metadata"""
+        """NamedTuple for a primitive value associated with Metadata."""
 
         value: str | Number
         meta: MetadataComponent
 
     class __NestedMeta(NamedTuple):
-        """NamedTuple for a nested value associated with Metadata"""
+        """NamedTuple for a nested value associated with Metadata."""
 
         value: dict[str, Any]
         meta: MetadataComponent
 
     class __DefinitionType(Enum):
-        """Indicates the type of data definition for an Attribute"""
+        """Indicates the type of data definition for an Attribute."""
 
         VALUE = auto()
         VALUE_LIST = auto()
         NESTED = auto()
         NESTED_LIST = auto()
 
-    _ERR_VALUE_MISSING = "Value not specified for Attribute '{}' - leave out if default shall be used (if defined)."
-    _ERR_LIST_EMPTY = "Attribute '{}' was assigned an empty list - please remove attribute or fill empty assignments."
-    _ERR_DICT_EMPTY = "Attribute '{}' was assigned an empty dictionary - please remove or fill empty assignments."
-    _ERR_MIXED_DATA = "Attribute '{}' was assigned a list with mixed complex and simple entries - please fix."
+    _ERR_CREATION = "Found error in specification of Attribute '{}'."
+    _ERR_VALUE_MISSING = "Value not specified for Attribute '{}' - leave this Attribute out or specify a value."
+    _ERR_LIST_EMPTY = "Attribute was assigned an empty list - please remove attribute or fill empty assignments."
+    _ERR_DICT_EMPTY = "Attribute was assigned an empty dictionary - please remove or fill empty assignments."
+    _ERR_MIXED_DATA = "Attribute was assigned a list with mixed complex and simple entries - please fix."
 
     def __init__(self, name: str, definitions: str | Number | list | dict) -> None:
-        """Parses an Attribute's definition"""
+        """Creates a new Attribute.
+
+        Args:
+            name: full name of the Attribute including the parent Attribute(s) names
+            definitions: of this Attribute including its inner elements, if any
+
+        Raises:
+            ScenarioError: if this Attribute or its inner elements could not be created, logged with level "ERROR"
+        """
         self._full_name = name
         if definitions is None:
-            log_and_raise(Attribute._ERR_VALUE_MISSING.format(name))
+            raise log_scenario_error(Attribute._ERR_VALUE_MISSING.format(name))
         super().__init__(definitions)
-        data_type = Attribute._get_data_type(name, definitions)
+        try:
+            data_type = Attribute._get_data_type(definitions)
+        except ValueError as e:
+            raise log_scenario_error(Attribute._ERR_CREATION.format(name)) from e
 
         self._value: str | Number | None = None
         self._value_list: list[Attribute.__ValueMeta] | None = None
@@ -59,51 +72,80 @@ class Attribute(Metadata):
         self._nested_list: list[Attribute.__NestedMeta] | None = None
 
         if data_type is Attribute.__DefinitionType.VALUE:
-            value = keys_to_lower(definitions)[Attribute.KEY_VALUE] if isinstance(definitions, dict) else definitions
-            self._value = value
+            self._value = self._extract_value(definitions).value  # type: ignore[arg-type]
         elif data_type is Attribute.__DefinitionType.VALUE_LIST:
-            self._value_list = self._extract_values(definitions)
+            self._value_list = self._extract_values(definitions)  # type: ignore[arg-type]
         elif data_type is Attribute.__DefinitionType.NESTED:
-            self._nested = Attribute._build_attribute_dict(name, definitions)
+            self._nested = Attribute._build_attribute_dict(name, definitions)  # type: ignore[arg-type]
         elif data_type is Attribute.__DefinitionType.NESTED_LIST:
             self._nested_list = []
             values = keys_to_lower(definitions)[Attribute.KEY_VALUES] if isinstance(definitions, dict) else definitions
-            for list_index, definition in enumerate(values):
+            for list_index, definition in enumerate(values):  # type: ignore[arg-type]
                 list_meta = MetadataComponent(definition)
                 list_extended_name = name + Attribute.NAME_STRING_SEPARATOR + str(list_index)
                 nested_items = Attribute._build_attribute_dict(list_extended_name, definition)
                 self._nested_list.append(Attribute.__NestedMeta(value=nested_items, meta=list_meta))
 
     @staticmethod
-    def _get_data_type(name: str, definitions: Any) -> Attribute.__DefinitionType:
-        """Returns type of data derived from given `definitions`"""
+    def _get_data_type(definitions: Any) -> Attribute.__DefinitionType:
+        """Returns type of data derived from given `definitions`.
+
+        Args:
+            definitions: to deduct the data type from
+
+        Returns:
+            data type derived from given definitions
+
+        Raises:
+            ValueError: if definitions are empty or could not be derived, logged with level "ERROR"
+        """
         if isinstance(definitions, list):
             if len(definitions) == 0:
-                log_and_raise(Attribute._ERR_LIST_EMPTY.format(name))
+                raise log_error(ValueError(Attribute._ERR_LIST_EMPTY))
             return Attribute._get_data_type_list(definitions)
         if isinstance(definitions, dict):
             if len(definitions) == 0:
-                log_and_raise(Attribute._ERR_DICT_EMPTY.format(name))
+                raise log_error(ValueError(Attribute._ERR_DICT_EMPTY))
             return Attribute._get_data_type_dict(definitions)
         return Attribute.__DefinitionType.VALUE
 
     @staticmethod
     def _get_data_type_list(definitions: list[Any]) -> Attribute.__DefinitionType:
-        """Returns type of data from a given non-empty list `definitions`"""
+        """Returns type of data from a given non-empty list `definitions`.
+
+        Args:
+            definitions: list of data to derive data type from
+
+        Returns:
+            data type of data list
+
+        Raises:
+            ValueError: if definitions represent a mix of simple and complex entries, logged with level "ERROR"
+        """
         if all(Attribute._is_value_definition(entry) for entry in definitions):
             return Attribute.__DefinitionType.VALUE_LIST
         if Attribute._is_list_of_dict(definitions):
             return Attribute.__DefinitionType.NESTED_LIST
-        log_and_raise(Attribute._ERR_MIXED_DATA.format(repr(definitions)))
+        raise log_error(ValueError(Attribute._ERR_MIXED_DATA))
 
     @staticmethod
     def _is_list_of_dict(definitions: list) -> bool:
-        """Returns True if given `definitions` is a list of (only) dict"""
+        """Returns True if given `definitions` is a list of (only) dict."""
         return all(isinstance(entry, dict) for entry in definitions)
 
     @staticmethod
     def _get_data_type_dict(definitions: dict[str, Any]) -> Attribute.__DefinitionType:
-        """Returns type of data from a given non-empty dict `definitions`"""
+        """Returns type of data from a given non-empty dict `definitions`.
+
+        Args:
+            definitions: to derive the data type from
+
+        Returns:
+            data type derived from given `definitions`
+
+        Raises:
+            ValueError: if definitions represent a mix of simple and complex entries, logged with level "ERROR"
+        """
         low_keys = keys_to_lower(definitions)
         if Attribute.KEY_VALUE in low_keys.keys():
             return Attribute.__DefinitionType.VALUE
@@ -113,19 +155,19 @@ class Attribute(Metadata):
                 return Attribute.__DefinitionType.VALUE_LIST
             if Attribute._is_list_of_dict(values):
                 return Attribute.__DefinitionType.NESTED_LIST
-            log_and_raise(Attribute._ERR_MIXED_DATA.format(repr(values)))
+            raise log_error(ValueError(Attribute._ERR_MIXED_DATA))
         return Attribute.__DefinitionType.NESTED
 
     @staticmethod
     def _is_value_definition(definition: Any) -> bool:
-        """Returns True if given `definition` is either a dict with a key `Value` or a simple value"""
+        """Returns True if given `definition` is either a dict with a key `Value` or a simple value."""
         if isinstance(definition, dict):
             return Attribute.KEY_VALUE in keys_to_lower(definition).keys()
         return isinstance(definition, (str, Number))
 
     @staticmethod
     def _extract_value(definition: str | Number | dict[str, Any]) -> Attribute.__ValueMeta:
-        """Creates a ValueMeta Tuple associating a Value with its optional metadata"""
+        """Creates a ValueMeta Tuple associating a Value with its optional metadata."""
         if isinstance(definition, dict):
             return Attribute.__ValueMeta(
                 value=keys_to_lower(definition)[Attribute.KEY_VALUE], meta=MetadataComponent(definition)
@@ -134,27 +176,38 @@ class Attribute(Metadata):
 
     @staticmethod
     def _extract_values(definition: list | dict) -> list[Attribute.__ValueMeta]:
-        """Creates a list of ValueMeta Tuples, each associating a value with optional metadata"""
+        """Creates a list of ValueMeta Tuples, each associating a value with optional metadata."""
         values = keys_to_lower(definition)[Attribute.KEY_VALUES] if isinstance(definition, dict) else definition
         return [Attribute._extract_value(entry) for entry in values]
 
     @staticmethod
-    def _build_attribute_dict(name: str, definitions: dict[str, Any]) -> dict[str, Attribute]:
-        """Returns a new dictionary containing Attributes generated from given `definitions`"""
+    def _build_attribute_dict(parent_name: str, definitions: dict[str, Any]) -> dict[str, Attribute]:
+        """Returns a new dictionary containing Attributes generated from given `definitions`.
+
+        Args:
+            parent_name: name of parent element
+            definitions: of the Attributes
+
+        Returns:
+            dictionary of Attributes created from given definitions
+
+        Raises:
+            ScenarioError: if any of the Attributes could not be created, logged with level "ERROR"
+        """
         inner_elements = {}
         for nested_name, value in definitions.items():
-            full_name = name + Attribute.NAME_STRING_SEPARATOR + nested_name
+            full_name = parent_name + Attribute.NAME_STRING_SEPARATOR + nested_name
             inner_elements[nested_name] = Attribute(full_name, value)
         return inner_elements
 
     @property
     def has_value(self) -> bool:
-        """Returns True if Attribute has any value assigned"""
+        """Returns True if Attribute has any value assigned."""
         return self._value is not None or self._value_list is not None
 
     @property
     def value(self) -> str | Number | list[str | Number] | None:
-        """Returns value or list of values if available on this Attribute (ignoring any Metadata), else None"""
+        """Returns value or list of values if available on this Attribute (ignoring any Metadata), else None."""
         if self._value is not None:
             return self._value
         if self._value_list is not None:
@@ -163,23 +216,23 @@ class Attribute(Metadata):
 
     @property
     def has_nested(self) -> bool:
-        """Returns True if nested Attributes are present, False otherwise; also returns False for nested lists"""
+        """Returns True if nested Attributes are present, False otherwise; also returns False for nested lists."""
         return self._nested is not None
 
     @property
     def nested(self) -> dict[str, Attribute]:
-        """Returns dictionary of all nested Attributes if nested Attributes are present, else None"""
-        return self._nested if self.has_nested else None
+        """Returns dictionary of all nested Attributes if nested Attributes are present, else empty dict."""
+        return self._nested if self._nested is not None else {}
 
     @property
     def has_nested_list(self) -> bool:
-        """Returns True if list of nested items is present"""
+        """Returns True if list of nested items is present."""
         return self._nested_list is not None
 
     @property
     def nested_list(self) -> list[dict[str, Attribute]]:
-        """Return list of all nested Attribute dictionaries if such are present, else None"""
-        return [entry.value for entry in self._nested_list] if self.has_nested_list else None
+        """Return list of all nested Attribute dictionaries if such are present, else an empty list."""
+        return [entry.value for entry in self._nested_list] if self._nested_list is not None else []
 
     def __repr__(self) -> str:
         return self._full_name

fameio/input/scenario/contract.py

@@ -3,18 +3,21 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import Any, Optional, Final
+from typing import Any, Final, overload
 
+from fameio.input import InputError
 from fameio.input.metadata import Metadata
-from fameio.logs import log
-from fameio.time import FameTime
+from fameio.input.scenario.attribute import Attribute
+from fameio.logs import log, log_error
+from fameio.time import FameTime, ConversionError
 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(Metadata):
-    """Contract between two Agents of a scenario"""
+    """Contract between two Agents of a scenario."""
+
+    class ContractError(InputError):
+        """An error that occurred while parsing Contract definitions."""
 
     KEY_SENDER: Final[str] = "SenderId".lower()
     KEY_RECEIVER: Final[str] = "ReceiverId".lower()
@@ -26,13 +29,15 @@ class Contract(Metadata):
 
     _ERR_MISSING_KEY = "Contract requires key '{}' but is missing it."
     _ERR_MULTI_CONTRACT_CORRUPT = (
-        "Definition of Contracts is valid only for One-to-One, One-to-many, Many-to-one, "
+        "Definition of Contracts is valid only for One-to-One, One-to-Many, Many-to-One, "
         "or N-to-N sender-to-receiver numbers. Found M-to-N pairing in Contract with "
         "Senders: {} and Receivers: {}."
     )
     _ERR_INTERVAL_NOT_POSITIVE = "Contract delivery interval must be a positive integer but was: {}"
     _ERR_SENDER_IS_RECEIVER = "Contract sender and receiver have the same id: {}"
     _ERR_DOUBLE_ATTRIBUTE = "Cannot add attribute '{}' to contract because it already exists."
+    _ERR_TIME_CONVERSION = "Contract item '{}' is an ill-formatted time: '{}'"
+    _ERR_PRODUCT_EMPTY = f"A Contract's `{KEY_PRODUCT}` must be a non-emtpy string."
 
     # pylint: disable=too-many-arguments, too-many-positional-arguments
     def __init__(
@@ -42,116 +47,198 @@ class Contract(Metadata):
         product_name: str,
         delivery_interval: int,
         first_delivery_time: int,
-        expiration_time: Optional[int] = None,
-        metadata: Optional[dict] = None,
+        expiration_time: int | None = None,
+        metadata: dict | None = None,
     ) -> None:
-        """Constructs a new Contract"""
+        """Constructs a new Contract.
+
+        Args:
+            sender_id: unique id of sender
+            receiver_id: unique id of receiver
+            product_name: name of contracted product
+            delivery_interval: time interval in steps between contract deliveries
+            first_delivery_time: absolute time of first contract execution
+            expiration_time: absolute time at which contract execution stops
+            metadata: any metadata associated with the contract
+
+        Returns:
+            new Contract
+
+        Raises:
+            ContractError: if delivery interval is invalid, logged on level "ERROR"
+        """
         super().__init__({self.KEY_METADATA: metadata} if metadata else None)
-        assert product_name != ""
+        if product_name.strip() == "":
+            raise log_error(self.ContractError(self._ERR_PRODUCT_EMPTY))
         if sender_id == receiver_id:
             log().warning(self._ERR_SENDER_IS_RECEIVER.format(sender_id))
         if delivery_interval <= 0:
-            raise ValueError(self._ERR_INTERVAL_NOT_POSITIVE.format(delivery_interval))
+            raise log_error(self.ContractError(self._ERR_INTERVAL_NOT_POSITIVE.format(delivery_interval)))
         self._sender_id = sender_id
         self._receiver_id = receiver_id
         self._product_name = product_name
         self._delivery_interval = delivery_interval
         self._first_delivery_time = first_delivery_time
         self._expiration_time = expiration_time
-        self._attributes = {}
+        self._attributes: dict = {}
 
     def _notify_data_changed(self):
-        """Placeholder method used to signal data changes to derived types"""
+        """Placeholder method used to signal data changes to derived types."""
 
     @property
     def product_name(self) -> str:
-        """Returns the product name of the contract"""
+        """Returns the product name of the contract."""
         return self._product_name
 
     @property
     def sender_id(self) -> int:
-        """Returns the sender ID of the contract"""
+        """Returns the sender ID of the contract."""
         return self._sender_id
 
     @property
     def display_sender_id(self) -> str:
-        """Returns the sender ID of the contract as a string for display purposes"""
+        """Returns the sender ID of the contract as a string for display purposes."""
         return f"#{self._sender_id}"
 
     @property
     def receiver_id(self) -> int:
-        """Returns the receiver ID of the contract"""
+        """Returns the receiver ID of the contract."""
         return self._receiver_id
 
     @property
     def display_receiver_id(self) -> str:
-        """Returns the receiver ID of the contract as a string for display purposes"""
+        """Returns the receiver ID of the contract as a string for display purposes."""
         return f"#{self._receiver_id}"
 
     @property
     def delivery_interval(self) -> int:
-        """Returns the delivery interval of the contract (in steps)"""
+        """Returns the delivery interval of the contract (in steps)."""
         return self._delivery_interval
 
     @property
     def first_delivery_time(self) -> int:
-        """Returns the first delivery time of the contract"""
+        """Returns the first delivery time of the contract."""
         return self._first_delivery_time
 
     @property
-    def expiration_time(self) -> Optional[int]:
-        """Returns the expiration time of the contract if available, None otherwise"""
+    def expiration_time(self) -> int | None:
+        """Returns the expiration time of the contract if available, None otherwise."""
         return self._expiration_time
 
     @property
     def attributes(self) -> dict[str, Attribute]:
-        """Returns dictionary of all Attributes of the contract"""
+        """Returns dictionary of all Attributes of the contract."""
         return self._attributes
 
     def add_attribute(self, name: str, value: Attribute) -> None:
-        """Adds a new attribute to the Contract (raise an error if it already exists)"""
+        """Adds a new attribute to the Contract.
+
+        Args:
+            name: of the attribute
+            value: of the attribute
+
+        Raises:
+            ContractError: if attribute already exists, logged on level "ERROR"
+        """
         if name in self._attributes:
-            raise ValueError(self._ERR_DOUBLE_ATTRIBUTE.format(name))
+            raise log_error(self.ContractError(self._ERR_DOUBLE_ATTRIBUTE.format(name)))
         self._attributes[name] = value
         self._notify_data_changed()
 
     @classmethod
     def from_dict(cls, definitions: dict) -> Contract:
-        """Parses Contract from given `definitions`"""
+        """Parses contract from given `definitions`.
+
+        Args:
+            definitions: dictionary representation of a contract
+
+        Returns:
+            new contract
+
+        Raises:
+            ContractError: if definitions are incomplete or erroneous, logged on level "ERROR"
+        """
         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)
-        first_delivery_time = FameTime.convert_string_if_is_datetime(
-            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)
-        expiration_time = FameTime.convert_string_if_is_datetime(expiration_time) if expiration_time else None
-
-        contract = cls(
-            sender_id,
-            receiver_id,
-            product_name,
-            delivery_interval,
-            first_delivery_time,
-            expiration_time,
-        )
+        sender_id = Contract._get_or_raise(definitions, Contract.KEY_SENDER, Contract._ERR_MISSING_KEY)
+        receiver_id = Contract._get_or_raise(definitions, Contract.KEY_RECEIVER, Contract._ERR_MISSING_KEY)
+        product_name = Contract._get_or_raise(definitions, Contract.KEY_PRODUCT, Contract._ERR_MISSING_KEY)
+
+        first_delivery_time = Contract._get_time(definitions, Contract.KEY_FIRST_DELIVERY)
+        delivery_interval = Contract._get_or_raise(definitions, Contract.KEY_INTERVAL, Contract._ERR_MISSING_KEY)
+        expiration_time = Contract._get_time(definitions, Contract.KEY_EXPIRE, mandatory=False)
+
+        contract = cls(sender_id, receiver_id, product_name, delivery_interval, first_delivery_time, expiration_time)
         contract._extract_metadata(definitions)
-        attribute_definitions = get_or_default(definitions, Contract.KEY_ATTRIBUTES, {})
-        contract._init_attributes_from_dict(attribute_definitions)
+        contract._init_attributes_from_dict(definitions.get(Contract.KEY_ATTRIBUTES, {}))
         return contract
 
+    @staticmethod
+    def _get_or_raise(dictionary: dict, key: str, error_message: str) -> Any:
+        """Returns value associated with `key` in given `dictionary`, or raises exception if key or value is missing.
+
+        Args:
+            dictionary: to search the key in
+            key: to be searched
+            error_message: to be logged and included in the raised exception if key is missing
+
+        Returns:
+            value associated with given key in given dictionary
+
+         Raises:
+             ContractError: if given key is not in given dictionary or value is None, logged on level "ERROR"
+        """
+        if key not in dictionary or dictionary[key] is None:
+            raise log_error(Contract.ContractError(error_message.format(key)))
+        return dictionary[key]
+
+    @staticmethod
+    @overload
+    def _get_time(definitions: dict, key: str) -> int: ...  # noqa: E704
+
+    @staticmethod
+    @overload
+    def _get_time(definitions: dict, key: str, mandatory: bool) -> int | None: ...  # noqa: E704
+
+    @staticmethod
+    def _get_time(definitions: dict, key: str, mandatory: bool = True) -> int | None:
+        """Extract time representation value at given key, and, if present, convert to integer, else return None.
+
+        Args:
+            definitions: to search given key in
+            key: to check for an associated value
+            mandatory: if true, also raises an error if key is missing
+
+        Returns:
+            None if key is not mandatory/present, else the integer representation of the time value associated with key
+
+        Raises:
+            ContractError: if found value could not be converted or mandatory value is missing, logged on level "ERROR"
+        """
+        if key in definitions:
+            value = definitions[key]
+            try:
+                return FameTime.convert_string_if_is_datetime(value)
+            except ConversionError as e:
+                raise log_error(Contract.ContractError(Contract._ERR_TIME_CONVERSION.format(key, value))) from e
+        if mandatory:
+            raise log_error(Contract.ContractError(Contract._ERR_MISSING_KEY.format(key)))
+        return 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 = {}
+        """Resets Contract `attributes` from dict.
+
+        Args:
+            attributes: key-value pairs of attributes to be set
+
+        Raises:
+            ContractError: if some of provided attributes were already present
+        """
         for name, value in attributes.items():
             full_name = f"{type}.{id}{name}"
             self.add_attribute(name, Attribute(full_name, value))
 
     def _to_dict(self) -> dict:
-        """Serializes the Contract content to a dict"""
+        """Serializes the Contract content to a dict."""
         result = {
             self.KEY_SENDER: self.sender_id,
             self.KEY_RECEIVER: self.receiver_id,
@@ -169,7 +256,20 @@ class Contract(Metadata):
 
     @staticmethod
     def split_contract_definitions(multi_definition: dict) -> list[dict]:
-        """Splits given `multi_definition` dictionary into list of individual Contract definitions"""
+        """Split given M:N `multi_definition` of contracts to multiple 1:1 contracts.
+
+        Splits given dictionary of contracts with potentially more than ore sender and/or receiver into a list
+        of individual contract definitions with one sender and one receiver.
+
+        Args:
+            multi_definition: contract definitions with potentially more than ore sender and/or receiver
+
+        Returns:
+            list of contract definitions with exactly one sender and receiver
+
+        Raises:
+            ContractError: if multi_definition is incomplete or erroneous, logged on level "ERROR"
+        """
         contracts = []
         base_data = {}
         multi_definition = keys_to_lower(multi_definition)
@@ -183,8 +283,12 @@ class Contract(Metadata):
         ]:
             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(
+            Contract._get_or_raise(multi_definition, Contract.KEY_SENDER, Contract._ERR_MISSING_KEY)
+        )
+        receivers = ensure_is_list(
+            Contract._get_or_raise(multi_definition, Contract.KEY_RECEIVER, Contract._ERR_MISSING_KEY)
+        )
         if len(senders) > 1 and len(receivers) == 1:
             for index, sender in enumerate(senders):
                 contracts.append(Contract._copy_contract(sender, receivers[0], base_data))
@@ -195,12 +299,12 @@ class Contract(Metadata):
             for index in range(len(senders)):  # pylint: disable=consider-using-enumerate
                 contracts.append(Contract._copy_contract(senders[index], receivers[index], base_data))
         else:
-            log_and_raise(Contract._ERR_MULTI_CONTRACT_CORRUPT.format(senders, receivers))
+            raise log_error(Contract.ContractError(Contract._ERR_MULTI_CONTRACT_CORRUPT.format(senders, receivers)))
         return contracts
 
     @staticmethod
     def _copy_contract(sender: int, receiver: int, base_data: dict) -> dict:
-        """Returns a new contract definition dictionary, with given `sender` and `receiver` and copied `base_data`"""
+        """Returns a new contract definition dictionary, with given `sender` and `receiver` and copied `base_data`."""
         contract = {
             Contract.KEY_SENDER: sender,
             Contract.KEY_RECEIVER: receiver,