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

CHANGELOG.md

@@ -1,14 +1,29 @@
-<!-- SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+<!-- SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 
 SPDX-License-Identifier: CC0-1.0 -->
 
+## [3.1.1](https://gitlab.com/fame-framework/fame-io/-/tags/v3.1.1) - 2025-03-21
+### Added
+- Add static code analysis to CI pipeline #231 (@dlr-cjs)
+
+### Fixed
+- Fixed unused default values for time series attributes #232 (@dlr_fn, @dlr-cjs)
+- Fixed bugs identified by static code analysis #231 (@dlr-cjs)
+- Fixed deprecated installation guide-line for testing fameio locally #231 (@dlr_fn)
+
+## [3.1.0](https://gitlab.com/fame-framework/fame-io/-/tags/v3.1.0) - 2025-01-29
+### Changed
+- Speed up of `makeFameRunConfig` for large CSV files #229 (@dlr-cjs, dlr_fn)
+- Improve testing of `tools.py` #227 (@dlr_fn)
+- Reorganize badges in tabular representation in `README.md` #226 (@dlr-cjs, dlr_fn)
+
 # Changelog
-## [3.0.0](https://gitlab.com/fame-framework/fame-io/-/tags/v3.0.0) - 2024-02-12
+## [3.0.0](https://gitlab.com/fame-framework/fame-io/-/tags/v3.0.0) - 2024-12-02
 ### Changed
 - **Breaking**: Update to fameprotobuf v2.0.2 #208, #215 (@dlr-cjs)
 - **Breaking**: Remove section `GeneralProperties.Output` in scenarios - any content there will be ignored #208 (@dlr-cjs)
 - **Breaking**: Set section `JavaPackages` in schema to be mandatory #208 (@dlr-cjs)
-- **Breaking**: Update header of protobuf files to "fameprotobufstreamfilev002    " - disable reading of old files #208, #214 (@dlr-cjs)
+- **Breaking**: Update header of protobuf files to `"fameprotobufstreamfilev002    "` - disable reading of old files #208, #214 (@dlr-cjs)
 - **Breaking**: Replace subparser from command-line argument `--time-merging` with a threefold argument #212 (@dlr-cjs)
 - **Breaking**: Attribute names "value", "values", and "metadata" are now disallowed as they are reserved for the Metadata implementation #217 (@dlr-cjs)
 - **Breaking**: Refactor package structure #137 (@dlr_fn, @dlr-cjs)

fameio/cli/__init__.py

@@ -1,5 +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 fameio.cli.parser import update_default_config
+from fameio.cli.parser import update_default_config  # noqa: F401

fameio/cli/options.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
 import argparse
@@ -12,8 +12,8 @@ class ParsableEnum(Enum):
     def instantiate(cls, name: str) -> Enum:
         try:
             return cls[name]
-        except KeyError:
-            raise argparse.ArgumentTypeError(f"'{name}' is not a valid option")
+        except KeyError as e:
+            raise argparse.ArgumentTypeError(f"'{name}' is not a valid option") from e
 
     def __str__(self):
         return self.name

fameio/cli/parser.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
 import copy
@@ -63,7 +63,7 @@ def add_output_argument(parser: ArgumentParser, default_value, help_text: str) -
 
 def add_log_level_argument(parser: ArgumentParser, default_value: str) -> None:
     """Adds optional argument 'log' to given `parser`"""
-    help_text = "choose logging level (default: {})".format(default_value)
+    help_text = f"choose logging level (default: {default_value})"
     # noinspection PyTypeChecker
     parser.add_argument(
         "-l",
@@ -139,7 +139,7 @@ def add_merge_time_argument(parser: ArgumentParser, defaults: Optional[list[int]
     if (
         not isinstance(defaults, list)
         or len(defaults) not in [0, 3]
-        or not all([isinstance(value, int) for value in defaults])
+        or not all(isinstance(value, int) for value in defaults)
     ):
         raise ArgumentTypeError(_ERR_INVALID_MERGING_DEFAULT.format(repr(defaults)))
 

fameio/input/__init__.py

@@ -6,22 +6,14 @@
 class InputError(Exception):
     """An error that occurred while parsing any kind of input"""
 
-    pass
-
 
 class SchemaError(InputError):
     """An error that occurred while parsing a Schema"""
 
-    pass
-
 
 class ScenarioError(InputError):
     """An error that occurred while parsing a Scenario"""
 
-    pass
-
 
 class YamlLoaderError(InputError):
     """An error that occurred while parsing a YAML file"""
-
-    pass

fameio/input/loader/controller.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 fnmatch import fnmatch
@@ -10,7 +10,7 @@ import yaml
 from fameio.input import YamlLoaderError
 from fameio.input.resolver import PathResolver
 from fameio.input.loader.loader import FameYamlLoader
-from fameio.logs import log, log_critical_and_raise
+from fameio.logs import log, log_critical
 
 
 class LoaderController:
@@ -44,7 +44,7 @@ class LoaderController:
     @staticmethod
     def _spawn_loader_builder() -> Callable[[IO], FameYamlLoader]:
         """Returns a new Callable that instantiates a new FameYamlLoader with an IO-stream"""
-        return lambda stream: FameYamlLoader(stream)
+        return lambda stream: FameYamlLoader(stream)  # pylint: disable=unnecessary-lambda
 
     def include(self, loader: FameYamlLoader, include_args: yaml.Node) -> Any:
         """Returns content loaded from the specified `include_args`"""
@@ -100,7 +100,7 @@ class LoaderController:
             if node:
                 if node not in data.keys():
                     message = LoaderController._ERR_NODE_MISSING.format(file_name, node_address, node)
-                    log_critical_and_raise(YamlLoaderError(message))
+                    raise log_critical(YamlLoaderError(message))
                 data = data[node]
         log().debug(LoaderController._DEBUG_SEARCH_NODE.format(file_name, node_address))
         return data
@@ -125,5 +125,4 @@ class LoaderController:
         if isinstance(new_data, list) and isinstance(previous_data, list):
             previous_data.extend(new_data)
             return previous_data
-        else:
-            log_critical_and_raise(YamlLoaderError(LoaderController._ERR_NOT_LIST))
+        raise log_critical(YamlLoaderError(LoaderController._ERR_NOT_LIST))

fameio/input/metadata.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 abc import ABC, abstractmethod
@@ -89,8 +89,6 @@ class ValueContainer:
     class ParseError(InputError):
         """An error that occurred while parsing content for metadata-annotated simple values"""
 
-        pass
-
     _ERR_VALUES_ILL_FORMATTED = "Only Lists and Dictionaries are supported here, but was: {}"
 
     def __init__(self, definition: Union[dict[str, Any], list[Any]] = None) -> None:
@@ -102,12 +100,11 @@ class ValueContainer:
         """Returns value data (and optional metadata) extracted from given `definition`"""
         if definition is None:
             return {}
-        elif isinstance(definition, dict):
+        if isinstance(definition, dict):
             return {key: MetadataComponent(key_definition) for key, key_definition in definition.items()}
-        elif isinstance(definition, list):
+        if isinstance(definition, list):
             return {key: MetadataComponent() for key in definition}
-        else:
-            raise ValueContainer.ParseError(ValueContainer._ERR_VALUES_ILL_FORMATTED.format(repr(definition)))
+        raise ValueContainer.ParseError(ValueContainer._ERR_VALUES_ILL_FORMATTED.format(repr(definition)))
 
     @property
     def values(self) -> dict[str, MetadataComponent]:

fameio/input/scenario/__init__.py

@@ -1,10 +1,9 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2025 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
-
-from .agent import Agent
-from .attribute import Attribute
-from .contract import Contract
-from .generalproperties import GeneralProperties
-from .scenario import Scenario
-from .stringset import StringSet
+from .agent import Agent  # noqa: F401
+from .attribute import Attribute  # noqa: F401
+from .contract import Contract  # noqa: F401
+from .generalproperties import GeneralProperties  # noqa: F401
+from .scenario import Scenario  # noqa: F401
+from .stringset import StringSet  # noqa: F401

fameio/input/scenario/agent.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
@@ -28,7 +28,7 @@ class Agent(Metadata):
     def __init__(self, agent_id: int, type_name: str, metadata: dict = None) -> None:
         """Constructs a new Agent"""
         super().__init__({Agent.KEY_METADATA: metadata} if metadata else None)
-        assert_or_raise(type(agent_id) is int and agent_id >= 0, self._ERR_MISSING_ID.format(agent_id))
+        assert_or_raise(isinstance(agent_id, int) and agent_id >= 0, self._ERR_MISSING_ID.format(agent_id))
         assert_or_raise(bool(type_name and type_name.strip()), self._ERR_MISSING_TYPE)
         self._id: int = agent_id
         self._type_name: str = type_name.strip()
@@ -79,7 +79,6 @@ class Agent(Metadata):
 
     def _notify_data_changed(self):
         """Placeholder method used to signal data changes to derived types"""
-        pass
 
     @property
     def id(self) -> int:
@@ -89,7 +88,7 @@ class Agent(Metadata):
     @property
     def display_id(self) -> str:
         """Returns the ID of the Agent as a string for display purposes"""
-        return "#{}".format(self._id)
+        return f"#{self._id}"
 
     @property
     def type_name(self) -> str:

fameio/input/scenario/attribute.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
@@ -81,26 +81,25 @@ class Attribute(Metadata):
             if len(definitions) == 0:
                 log_and_raise(Attribute._ERR_LIST_EMPTY.format(name))
             return Attribute._get_data_type_list(definitions)
-        elif isinstance(definitions, dict):
+        if isinstance(definitions, dict):
             if len(definitions) == 0:
                 log_and_raise(Attribute._ERR_DICT_EMPTY.format(name))
             return Attribute._get_data_type_dict(definitions)
-        else:
-            return Attribute.__DefinitionType.VALUE
+        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`"""
-        if all([Attribute._is_value_definition(entry) for entry in definitions]):
+        if all(Attribute._is_value_definition(entry) for entry in definitions):
             return Attribute.__DefinitionType.VALUE_LIST
-        elif Attribute._is_list_of_dict(definitions):
+        if Attribute._is_list_of_dict(definitions):
             return Attribute.__DefinitionType.NESTED_LIST
         log_and_raise(Attribute._ERR_MIXED_DATA.format(repr(definitions)))
 
     @staticmethod
     def _is_list_of_dict(definitions: list) -> bool:
         """Returns True if given `definitions` is a list of (only) dict"""
-        return all([isinstance(entry, dict) for entry in definitions])
+        return all(isinstance(entry, dict) for entry in definitions)
 
     @staticmethod
     def _get_data_type_dict(definitions: dict[str, Any]) -> Attribute.__DefinitionType:
@@ -108,11 +107,11 @@ class Attribute(Metadata):
         low_keys = keys_to_lower(definitions)
         if Attribute.KEY_VALUE in low_keys.keys():
             return Attribute.__DefinitionType.VALUE
-        elif Attribute.KEY_VALUES in low_keys.keys():
+        if Attribute.KEY_VALUES in low_keys.keys():
             values = low_keys[Attribute.KEY_VALUES]
-            if all([Attribute._is_value_definition(entry) for entry in values]):
+            if all(Attribute._is_value_definition(entry) for entry in values):
                 return Attribute.__DefinitionType.VALUE_LIST
-            elif Attribute._is_list_of_dict(values):
+            if Attribute._is_list_of_dict(values):
                 return Attribute.__DefinitionType.NESTED_LIST
             log_and_raise(Attribute._ERR_MIXED_DATA.format(repr(values)))
         return Attribute.__DefinitionType.NESTED
@@ -158,7 +157,7 @@ class Attribute(Metadata):
         """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
-        elif self._value_list is not None:
+        if self._value_list is not None:
             return [item.value for item in self._value_list]
         return None
 
@@ -188,16 +187,17 @@ class Attribute(Metadata):
     def _to_dict(self) -> dict[str, Any]:
         if self._value is not None:
             return {self.KEY_VALUE: self._value}
-        elif self._value_list is not None:
+        if self._value_list is not None:
             return {
                 self.KEY_VALUES: [{self.KEY_VALUE: entry.value, **entry.meta.to_dict()} for entry in self._value_list]
             }
-        elif self._nested is not None:
+        if self._nested is not None:
             return {name: attribute.to_dict() for name, attribute in self.nested.items()}
-        elif self._nested_list is not None:
+        if self._nested_list is not None:
             return {
                 self.KEY_VALUES: [
                     {**{name: attribute.to_dict() for name, attribute in entry.value.items()}, **entry.meta.to_dict()}
                     for entry in self._nested_list
                 ]
             }
+        return {}

fameio/input/scenario/contract.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2023 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
@@ -34,6 +34,7 @@ class Contract(Metadata):
     _ERR_SENDER_IS_RECEIVER = "Contract sender and receiver have the same id: {}"
     _ERR_DOUBLE_ATTRIBUTE = "Cannot add attribute '{}' to contract because it already exists."
 
+    # pylint: disable=too-many-arguments, too-many-positional-arguments
     def __init__(
         self,
         sender_id: int,
@@ -61,7 +62,6 @@ class Contract(Metadata):
 
     def _notify_data_changed(self):
         """Placeholder method used to signal data changes to derived types"""
-        pass
 
     @property
     def product_name(self) -> str:
@@ -76,7 +76,7 @@ class Contract(Metadata):
     @property
     def display_sender_id(self) -> str:
         """Returns the sender ID of the contract as a string for display purposes"""
-        return "#{}".format(self._sender_id)
+        return f"#{self._sender_id}"
 
     @property
     def receiver_id(self) -> int:
@@ -86,7 +86,7 @@ class Contract(Metadata):
     @property
     def display_receiver_id(self) -> str:
         """Returns the receiver ID of the contract as a string for display purposes"""
-        return "#{}".format(self._receiver_id)
+        return f"#{self._receiver_id}"
 
     @property
     def delivery_interval(self) -> int:
@@ -186,13 +186,13 @@ class Contract(Metadata):
         senders = ensure_is_list(get_or_raise(multi_definition, Contract.KEY_SENDER, Contract._ERR_MISSING_KEY))
         receivers = ensure_is_list(get_or_raise(multi_definition, Contract.KEY_RECEIVER, Contract._ERR_MISSING_KEY))
         if len(senders) > 1 and len(receivers) == 1:
-            for index in range(len(senders)):
-                contracts.append(Contract._copy_contract(senders[index], receivers[0], base_data))
+            for index, sender in enumerate(senders):
+                contracts.append(Contract._copy_contract(sender, receivers[0], base_data))
         elif len(senders) == 1 and len(receivers) > 1:
-            for index in range(len(receivers)):
-                contracts.append(Contract._copy_contract(senders[0], receivers[index], base_data))
+            for index, receiver in enumerate(receivers):
+                contracts.append(Contract._copy_contract(senders[0], receiver, base_data))
         elif len(senders) == len(receivers):
-            for index in range(len(senders)):
+            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))

fameio/input/scenario/exception.py

@@ -1,38 +1,35 @@
-# 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 typing import NoReturn, Any, Union
 
 from fameio.input import ScenarioError
-from fameio.logs import log_error_and_raise, log
+from fameio.logs import log_error, log
 
 _DEFAULT_USED = "Using default value '{}' for missing key '{}'"
 
 
 def log_and_raise(message: str) -> NoReturn:
     """Raises ScenarioError with given `message`"""
-    log_error_and_raise(ScenarioError(message))
+    raise log_error(ScenarioError(message))
 
 
 def get_or_raise(dictionary: dict, key: str, message: str) -> Union[Any, NoReturn]:
     """Returns value associated with `key` in given `dictionary`, or raises ScenarioException if key is missing"""
     if key not in dictionary or dictionary[key] is None:
-        log_error_and_raise(ScenarioError(message.format(key)))
-    else:
-        return dictionary[key]
+        raise log_error(ScenarioError(message.format(key)))
+    return dictionary[key]
 
 
 def assert_or_raise(assertion: bool, msg: str) -> None:
     """Raises new ScenarioError with given `msg` if `assertion` is False"""
     if not assertion:
-        log_error_and_raise(ScenarioError(msg))
+        raise log_error(ScenarioError(msg))
 
 
 def get_or_default(dictionary: dict, key: str, default_value) -> Any:
     """Returns value associated with `key` in given `dictionary`, or the given `default_value` if key is missing"""
     if key in dictionary and dictionary[key] is not None:
         return dictionary[key]
-    else:
-        log().debug(_DEFAULT_USED.format(default_value, key))
-        return default_value
+    log().debug(_DEFAULT_USED.format(default_value, key))
+    return default_value

fameio/input/schema/__init__.py

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

fameio/input/schema/agenttype.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
@@ -7,7 +7,7 @@ from typing import Any, Final
 
 from fameio.input import InputError, SchemaError
 from fameio.input.metadata import Metadata, MetadataComponent, ValueContainer
-from fameio.logs import log_error_and_raise, log
+from fameio.logs import log, log_error
 from fameio.tools import keys_to_lower
 from .attribute import AttributeSpecs
 
@@ -36,7 +36,7 @@ class AgentType(Metadata):
         """
         super().__init__()
         if not name or name.isspace():
-            log_error_and_raise(SchemaError(AgentType._ERR_NAME_INVALID.format(name)))
+            raise log_error(SchemaError(AgentType._ERR_NAME_INVALID.format(name)))
         self._name = name
         self._attributes: dict[str, AttributeSpecs] = {}
         self._products: ValueContainer = ValueContainer()
@@ -86,12 +86,11 @@ class AgentType(Metadata):
         """Returns ValueContainer for `section` of in specifications of `agent_type` extracted from given `values`"""
         try:
             data = ValueContainer(values)
-        except InputError:
-            log_error_and_raise(SchemaError(AgentType._ERR_UNKNOWN_STRUCTURE.format(section, agent_type, values)))
-        else:
-            if not all([isinstance(item, str) for item in data.as_list()]):
-                log_error_and_raise(SchemaError(AgentType._ERR_NO_STRING.format(section, agent_type, data.as_list())))
-            return data
+        except InputError as e:
+            raise log_error(SchemaError(AgentType._ERR_UNKNOWN_STRUCTURE.format(section, agent_type, values))) from e
+        if not all(isinstance(item, str) for item in data.as_list()):
+            raise log_error(SchemaError(AgentType._ERR_NO_STRING.format(section, agent_type, data.as_list())))
+        return data
 
     @property
     def name(self) -> str: