baldertest 0.1.0b11__tar.gz → 0.1.0b12__tar.gz

{baldertest-0.1.0b11/src/baldertest.egg-info → baldertest-0.1.0b12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: baldertest
-Version: 0.1.0b11
+Version: 0.1.0b12
 Summary: balder: reusable scenario based test framework
 Home-page: https://docs.balder.dev
 Author: Max Stahlschmidt and others

{baldertest-0.1.0b11 → baldertest-0.1.0b12}/src/_balder/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0b11'
+__version__ = version = '0.1.0b12'
 __version_tuple__ = version_tuple = (0, 1, 0)

{baldertest-0.1.0b11 → baldertest-0.1.0b12}/src/_balder/controllers/device_controller.py

@@ -1,4 +1,6 @@
 from __future__ import annotations
+
+import copy
 from typing import Dict, List, Type, Union, TYPE_CHECKING
 
 import sys
@@ -443,10 +445,15 @@ class DeviceController(BaseDeviceController, ABC):
         if all_instanced_features is None:
             # has no features -> skip
             return
-        for _, cur_feature in all_instanced_features.items():
-            if cur_feature.active_vdevices != {}:
+        for cur_attr_name, cur_feature in all_instanced_features.items():
+            # clone feature and its active_device dict to make sure that shared instances in parent classes are handled
+            # correctly
+            new_feature = copy.copy(cur_feature)
+            new_feature.active_vdevices = {**cur_feature.active_vdevices}
+            setattr(self.related_cls, cur_attr_name, new_feature)
+            if new_feature.active_vdevices != {}:
                 # do something only if there exists an internal mapping
-                for cur_mapped_vdevice, cur_mapped_device in cur_feature.active_vdevices.items():
+                for cur_mapped_vdevice, cur_mapped_device in new_feature.active_vdevices.items():
                     if isinstance(cur_mapped_device, str):
                         resolved_device = \
                             scenario_or_setup_controller.get_inner_device_class_by_string(cur_mapped_device)
@@ -454,5 +461,5 @@ class DeviceController(BaseDeviceController, ABC):
                             raise RuntimeError(
                                 f"found no possible matching name while trying to resolve "
                                 f"the given vDevice string `{cur_mapped_vdevice}` in feature "
-                                f"`{cur_feature.__class__.__name__}`")
-                        cur_feature.active_vdevices[cur_mapped_vdevice] = resolved_device
+                                f"`{new_feature.__class__.__name__}`")
+                        new_feature.active_vdevices[cur_mapped_vdevice] = resolved_device

{baldertest-0.1.0b11 → baldertest-0.1.0b12}/src/_balder/executor/variation_executor.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-import itertools
-from typing import Type, Union, List, Dict, Tuple, TYPE_CHECKING
+from typing import Type, Union, List, Dict, TYPE_CHECKING
 
 import inspect
 import logging
 from _balder.cnnrelations import OrConnectionRelation
 from _balder.device import Device
 from _balder.connection import Connection
+from _balder.feature_replacement_mapping import FeatureReplacementMapping
 from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
 from _balder.executor.basic_executable_executor import BasicExecutableExecutor
@@ -16,6 +16,7 @@ from _balder.executor.unresolved_parametrized_testcase_executor import Unresolve
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.routing_path import RoutingPath
 from _balder.unmapped_vdevice import UnmappedVDevice
+from _balder.feature_vdevice_mapping import FeatureVDeviceMapping
 from _balder.controllers import DeviceController, VDeviceController, FeatureController, NormalScenarioSetupController
 from _balder.exceptions import NotApplicableVariationException, UnclearAssignableFeatureConnectionError
 
@@ -23,7 +24,6 @@ if TYPE_CHECKING:
     from _balder.setup import Setup
     from _balder.feature import Feature
     from _balder.scenario import Scenario
-    from _balder.vdevice import VDevice
     from _balder.controllers.scenario_controller import ScenarioController
     from _balder.controllers.setup_controller import SetupController
     from _balder.executor.scenario_executor import ScenarioExecutor
@@ -50,12 +50,10 @@ class VariationExecutor(BasicExecutableExecutor):
         self._routings: Dict[Connection, List[RoutingPath]] = {}
         # buffer variable to save the feature replacement after it was determined with
         # `determine_feature_replacement_and_vdevice_mappings()`
-        self._feature_replacement: \
-            Union[None, Dict[Type[Device], Dict[str, Tuple[Union[Feature, None], Feature]]]] = None
+        self._feature_replacement: Union[None, Dict[Type[Device], FeatureReplacementMapping]] = None
         # buffer variable to save the feature replacement after it was determined with
         # `determine_feature_replacement_and_vdevice_mappings()`
-        self._abs_setup_feature_vdevice_mappings: \
-            Union[None, Dict[Type[Device], Dict[Feature, Dict[Type[VDevice], Type[Device]]]]] = None
+        self._abs_setup_feature_vdevice_mappings: Union[None, Dict[Type[Device], FeatureVDeviceMapping]] = None
 
         # contains the absolute scenario device connections for the current variation
         self._abs_variation_scenario_device_connections: Union[List[Connection], None] = None
@@ -67,8 +65,7 @@ class VariationExecutor(BasicExecutableExecutor):
         # contains the original active vdevice mappings for all scenario and setup devices (will be managed by
         # `update_active_vdevice_device_mappings_in_scenario_and_setup_devices()` and
         # `revert_active_vdevice_device_mappings_in_scenario_and_setup_devices()`)
-        self._original_active_vdevice_mappings: \
-            Dict[Type[Device], Dict[Feature, Dict[Type[VDevice], Type[Device]]]] = {}
+        self._original_active_vdevice_mappings: Dict[Type[Device], FeatureVDeviceMapping] = {}
 
         # is True if the applicability check was done
         self._applicability_check_done = False
@@ -138,18 +135,17 @@ class VariationExecutor(BasicExecutableExecutor):
         return self._fixture_manager
 
     @property
-    def feature_replacement(self) -> Dict[Type[Device], Dict[str, Tuple[Union[Feature, None], Feature]]]:
+    def feature_replacement(self) -> Dict[Type[Device], FeatureReplacementMapping]:
         """
-        this property is a dictionary with every scenario device as key and a dictionary as value - the value dictionary
-        contains a tuple (inner dict value) for every attribute name(inner dict key) - the tuples always consist of two
-        elements, the old feature as first item of the tuple (the instantiated feature from the scenario if it exists,
-        otherwise this is None) and the new feature as second item (the feature of the related Setup-Device)
+        this property is a dictionary with every scenario device as key and feature-replacement-mapping as value - the
+        mappings hold at least information about the attribute name of the feature in scenario device, the old
+        scenario-feature the instantiated feature from the scenario if it exists, otherwise this is None) and the
+        new feature as second item (the feature of the related Setup-Device)
         """
         return self._feature_replacement
 
     @property
-    def abs_setup_feature_vdevice_mappings(self) \
-            -> Dict[Type[Device], Dict[Feature, Dict[Type[VDevice], Type[Device]]]]:
+    def abs_setup_feature_vdevice_mappings(self) -> Dict[Type[Device], FeatureVDeviceMapping]:
         """returns the feature replacement that was determined with
         `determine_feature_replacement_and_vdevice_mappings()`"""
         return self._abs_setup_feature_vdevice_mappings
@@ -230,26 +226,22 @@ class VariationExecutor(BasicExecutableExecutor):
         vDevices-Mappings (so the mapped setup-devices) implements all features that are defined in the vDevices
         """
 
-        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
+        for cur_scenario_device, cur_replacement_mapping in self.feature_replacement.items():
             cur_setup_device = self.get_setup_device_for(scenario_device=cur_scenario_device)
             all_inner_setup_features = \
                 DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
 
-            # describes the mapping from the new setup feature (key) to the instantiated scenario feature (value)
-            #  note that this dictionary only contains the required one
-            setup_to_scenario_feature_mapping: Dict[Type[Feature], Feature] = {
-                cur_replacement_tuple[1]: cur_replacement_tuple[0]
-                for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items()
-                if cur_replacement_tuple[0] is not None}
-
             # now secure that all features are available in the corresponding setup device, that are defined in the
             #  mapped vDevice
             for _, cur_setup_feature_obj in all_inner_setup_features.items():
-                # only check if there is a requirement of this feature (the feature is required by the Scenario)
-                if cur_setup_feature_obj.__class__ not in setup_to_scenario_feature_mapping.keys():
-                    # ignore this, because no requirement for this feature
+                related_scenario_feature_obj = \
+                    cur_replacement_mapping.get_replaced_scenario_feature_for(cur_setup_feature_obj)
+
+                # only check if this feature is required by the scenario
+                if related_scenario_feature_obj is None:
+                    # ignore this, because this feature is not used in the scenario
                     continue
-                related_scenario_feature_obj = setup_to_scenario_feature_mapping[cur_setup_feature_obj.__class__]
+
                 # get vDevice and device mapping
                 partner_scenario_vdevice, partner_scenario_device = \
                     related_scenario_feature_obj.active_vdevice_device_mapping
@@ -258,7 +250,7 @@ class VariationExecutor(BasicExecutableExecutor):
                     # ignore because no mapping exist here
                     continue
 
-                partner_setup_device = self.get_setup_device_for(scenario_device=partner_scenario_vdevice)
+                partner_setup_device = self.get_setup_device_for(scenario_device=partner_scenario_device)
                 # get the related vDevice on setup view that is currently active
                 mapped_setup_vdevices = [
                     cur_vdevice for cur_vdevice
@@ -388,15 +380,20 @@ class VariationExecutor(BasicExecutableExecutor):
         :raises NotApplicableVariationError: will be thrown if this variation cannot be applied, because the setup-/
                                              scenario-device-features can not be resolved
         """
-        feature_replacement = {scenario_dev: {} for scenario_dev in self.base_device_mapping.keys()}
-        abs_setup_vdevice_mappings = {setup_dev: {} for setup_dev in self.base_device_mapping.values()}
+        feature_replacement = {
+            scenario_dev: FeatureReplacementMapping() for scenario_dev in self.base_device_mapping.keys()
+        }
+
+        abs_setup_vdevice_mappings = {
+            setup_dev: FeatureVDeviceMapping() for setup_dev in self.base_device_mapping.values()
+        }
         for cur_scenario_device, cur_setup_device in self.base_device_mapping.items():
             cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
 
             all_assigned_setup_features = []
-            cur_scenario_device_orig_features = \
-                DeviceController.get_for(cur_scenario_device).get_original_instanced_feature_objects()
-            for cur_attr_name, cur_scenario_feature_obj in cur_scenario_device_orig_features.items():
+            cur_scenario_device_features = \
+                DeviceController.get_for(cur_scenario_device).get_all_instantiated_feature_objects()
+            for cur_attr_name, cur_scenario_feature_obj in cur_scenario_device_features.items():
                 active_scenario_vdevice, mapped_scenario_device = cur_scenario_feature_obj.active_vdevice_device_mapping
 
                 cur_setup_feature_objs = self._get_matching_setup_features_for(
@@ -431,7 +428,7 @@ class VariationExecutor(BasicExecutableExecutor):
                             f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
 
                 all_assigned_setup_features.append(cur_setup_feature_obj)
-                if cur_attr_name not in feature_replacement[cur_scenario_device].keys():
+                if cur_attr_name not in feature_replacement[cur_scenario_device].attr_names:
                     cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
 
                     used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
@@ -446,26 +443,41 @@ class VariationExecutor(BasicExecutableExecutor):
                                           if cur_vdevice.__name__ == active_scenario_vdevice.__name__]
                         used_setup_vdevice = setup_vdevices[0]
                         # set the mapping
-                        abs_setup_vdevice_mappings[cur_setup_device][cur_setup_feature_obj] = {
-                            used_setup_vdevice: self.get_setup_device_for(mapped_scenario_device)}
+                        abs_setup_vdevice_mappings[cur_setup_device].add(
+                            feature=cur_setup_feature_obj,
+                            mappings={
+                                used_setup_vdevice: self.get_setup_device_for(mapped_scenario_device)
+                            }
+                        )
                     # if there is a vDevice mapping on setup level, but not on scenario level, so directly update the
                     # VDevice-Device-Mapping there
                     elif mapped_scenario_device is None and mapped_setup_device is not None:
-                        abs_setup_vdevice_mappings[cur_setup_device][cur_setup_feature_obj] = {
-                            used_setup_vdevice: mapped_setup_device}
+                        abs_setup_vdevice_mappings[cur_setup_device].add(
+                            feature=cur_setup_feature_obj,
+                            mappings={
+                                used_setup_vdevice: mapped_setup_device
+                            }
+                        )
+
+                    feature_replacement[cur_scenario_device].add(attr_name=cur_attr_name,
+                                                                 scenario_feature=cur_scenario_feature_obj,
+                                                                 setup_feature=cur_setup_feature_obj)
 
-                    feature_replacement[cur_scenario_device][cur_attr_name] = \
-                        (cur_scenario_feature_obj, cur_setup_feature_obj)
             # also add all setup features that are not assigned as autonomous features
             for cur_setup_feature in cur_setup_features.values():
                 if cur_setup_feature not in all_assigned_setup_features:
                     # determine free name
                     idx = 0
                     autonomous_name = None
-                    while autonomous_name is None or autonomous_name in feature_replacement[cur_scenario_device].keys():
+                    while (autonomous_name is None
+                           or autonomous_name in feature_replacement[cur_scenario_device].attr_names):
                         autonomous_name = f"_autonomous_feat_{idx}"
                         idx += 1
-                    feature_replacement[cur_scenario_device][autonomous_name] = (None, cur_setup_feature)
+                    feature_replacement[cur_scenario_device].add(
+                        attr_name=autonomous_name,
+                        scenario_feature=None,
+                        setup_feature=cur_setup_feature
+                    )
 
         # set the result to internal properties
         self._feature_replacement = feature_replacement
@@ -531,20 +543,18 @@ class VariationExecutor(BasicExecutableExecutor):
         This method ensures that the (mostly abstract) feature instances of a scenario are exchanged with the
         feature instances of the assigned setup devices
         """
-        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
-            for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items():
-                _, new_feature_obj = cur_replacement_tuple
-                setattr(cur_scenario_device, cur_attr_name, new_feature_obj)
+        for cur_scenario_device, cur_replacement_mapping in self.feature_replacement.items():
+            for cur_feature_mapping in cur_replacement_mapping.mappings:
+                setattr(cur_scenario_device, cur_feature_mapping.attr_name, cur_feature_mapping.setup_feature)
 
     def revert_scenario_device_feature_instances(self):
         """
         This method ensures that all initialized feature instances of a scenario are set back to the initial given
         features.
         """
-        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
-            for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items():
-                old_instantiated_feature_obj, _ = cur_replacement_tuple
-                setattr(cur_scenario_device, cur_attr_name, old_instantiated_feature_obj)
+        for cur_scenario_device, cur_replacement_mapping in self.feature_replacement.items():
+            for cur_feature_mapping in cur_replacement_mapping.mappings:
+                setattr(cur_scenario_device, cur_feature_mapping.attr_name, cur_feature_mapping.scenario_feature)
 
     def update_active_vdevice_device_mappings_in_all_features(self):
         """
@@ -552,28 +562,28 @@ class VariationExecutor(BasicExecutableExecutor):
         scenario-device classes are set correctly.
         """
 
-        for cur_setup_device, feature_dict in self.abs_setup_feature_vdevice_mappings.items():
+        for cur_setup_device, feature_vdevice_mapping in self.abs_setup_feature_vdevice_mappings.items():
             if cur_setup_device not in self._original_active_vdevice_mappings.keys():
-                self._original_active_vdevice_mappings[cur_setup_device] = {}
-            for cur_setup_feature, mapping_dict in feature_dict.items():
+                self._original_active_vdevice_mappings[cur_setup_device] = FeatureVDeviceMapping()
+            for cur_setup_feature in feature_vdevice_mapping.features:
+                vdev_dev_mappings_of_setup_feat = feature_vdevice_mapping.get_mappings_for_feature(cur_setup_feature)
 
-                cur_setup_feature_vdevice = list(mapping_dict.keys())[0]
-                cur_mapped_setup_device = list(mapping_dict.values())[0]
+                cur_setup_feature_vdevice = vdev_dev_mappings_of_setup_feat[0].vdevice
+                cur_mapped_setup_device = vdev_dev_mappings_of_setup_feat[0].device
 
                 # first save old value to revert it later
-                self._original_active_vdevice_mappings[cur_setup_device][cur_setup_feature] = \
-                    cur_setup_feature.active_vdevices
+                self._original_active_vdevice_mappings[cur_setup_device].add(
+                    feature=cur_setup_feature,
+                    mappings=cur_setup_feature.active_vdevices
+                )
                 # now set new value
                 cur_setup_feature.active_vdevices = {cur_setup_feature_vdevice: cur_mapped_setup_device}
 
                 # now also determine the mapping for the scenario-feature (if there exists one)
                 cur_scenario_device = self.get_scenario_device_for(cur_setup_device)
-                cur_scenario_feature = None
-                for cur_replacement_scenario_feature, cur_replacement_setup_feature in \
-                        self.feature_replacement[cur_scenario_device].values():
-                    if cur_replacement_setup_feature == cur_setup_feature:
-                        cur_scenario_feature = cur_replacement_scenario_feature
-                        break
+                cur_scenario_feature = self.feature_replacement[cur_scenario_device].get_replaced_scenario_feature_for(
+                    cur_setup_feature
+                )
                 if cur_scenario_feature is None:
                     # there exists no scenario feature -> we can ignore this
                     pass
@@ -587,10 +597,12 @@ class VariationExecutor(BasicExecutableExecutor):
                         # only if there exists exactly one scenario vdevice with the same name
 
                         if cur_scenario_device not in self._original_active_vdevice_mappings.keys():
-                            self._original_active_vdevice_mappings[cur_scenario_device] = {}
+                            self._original_active_vdevice_mappings[cur_scenario_device] = FeatureVDeviceMapping()
                         # first save old value to revert it later
-                        self._original_active_vdevice_mappings[cur_scenario_device][cur_scenario_feature] = \
-                            cur_scenario_feature.active_vdevices
+                        self._original_active_vdevice_mappings[cur_scenario_device].add(
+                            feature=cur_scenario_feature,
+                            mappings=cur_scenario_feature.active_vdevices
+                        )
                         # now set new value
                         cur_scenario_feature.active_vdevices = \
                             {cur_scenario_feature_vdevice[0]: self.get_scenario_device_for(cur_mapped_setup_device)}
@@ -598,10 +610,14 @@ class VariationExecutor(BasicExecutableExecutor):
     def revert_active_vdevice_device_mappings_in_all_features(self):
         """
         This method ensures that the `active_vdevices` property that was changed with
-        `update_active_vdevice_device_mappings()` will be reverted correctly.
+        `update_active_vdevice_device_mappings_in_all_features()` will be reverted correctly.
         """
-        for _, cur_feature_mapping_dict in self._original_active_vdevice_mappings.items():
-            for cur_feature, cur_original_mapping in cur_feature_mapping_dict.items():
+        for cur_feature_vdevice_mapping in self._original_active_vdevice_mappings.values():
+            for cur_feature in cur_feature_vdevice_mapping.features:
+                cur_original_mapping = {
+                    mapping.vdevice:mapping.device
+                    for mapping in cur_feature_vdevice_mapping.get_mappings_for_feature(cur_feature)
+                }
                 cur_feature.active_vdevices = cur_original_mapping
 
     def exchange_unmapped_vdevice_references(self):
@@ -661,7 +677,7 @@ class VariationExecutor(BasicExecutableExecutor):
                 cur_vdevice, cur_device = cur_feature.active_vdevice_device_mapping
                 if cur_vdevice is not None and cur_device is not None:
                     cur_vdevice_controller = VDeviceController.get_for(cur_vdevice)
-                    cur_vdevice_all_features = cur_vdevice_controller.get_original_instanced_feature_objects()
+                    cur_vdevice_all_features = cur_vdevice_controller.get_all_instantiated_feature_objects()
 
                     cur_device_controller = DeviceController.get_for(cur_device)
                     cur_device_all_features = cur_device_controller.get_all_instantiated_feature_objects()
@@ -722,64 +738,54 @@ class VariationExecutor(BasicExecutableExecutor):
 
         # now iterate over every feature, that is used by the scenario and determine the class-based feature connections
         # of the mapped scenario feature (and its vDevice)
-        for cur_setup_device, feature_dict in self.abs_setup_feature_vdevice_mappings.items():
+        for cur_setup_device, feature_vdev_mapping in self.abs_setup_feature_vdevice_mappings.items():
             cur_scenario_device = self.get_scenario_device_for(cur_setup_device)
-            for cur_setup_feature, mapping_dict in feature_dict.items():
-                feature_replacement = {
-                    cur_tuple[1]: cur_tuple[0] for _, cur_tuple in self.feature_replacement[cur_scenario_device].items()
-                }
-                cur_scenario_feature: Feature = feature_replacement[cur_setup_feature]
-                cur_setup_feature_vdevice = list(mapping_dict.keys())[0]
-                cur_mapped_setup_device = list(mapping_dict.values())[0]
+            for cur_setup_feature, vdev_mappings_of_setup_feature in feature_vdev_mapping.items():
+                cur_scenario_feature: Feature = (
+                    self.feature_replacement[cur_scenario_device].get_replaced_scenario_feature_for(
+                        setup_feature=cur_setup_feature)
+                )
 
-                if cur_mapped_setup_device not in self.base_device_mapping.values():
+                if vdev_mappings_of_setup_feature[0].device not in self.base_device_mapping.values():
                     raise NotApplicableVariationException(
-                        f'the mapped setup device `{cur_mapped_setup_device.__qualname__}` which is mapped to the '
-                        f'VDevice `{cur_setup_feature_vdevice.__qualname__}` is no part of this variation')
+                        f'the mapped setup device `{vdev_mappings_of_setup_feature[0].device.__qualname__}` which is '
+                        f'mapped to the VDevice `{vdev_mappings_of_setup_feature[0].vdevice.__qualname__}` is no part '
+                        f'of this variation')
 
-                cur_mapped_scenario_device = self.get_scenario_device_for(cur_mapped_setup_device)
+                cur_mapped_scenario_device = self.get_scenario_device_for(vdev_mappings_of_setup_feature[0].device)
 
                 # get relevant class based connections for the current feature on setup level (this is really be used
                 # here)
-                feature_cnn = \
-                    FeatureController.get_for(
-                        cur_setup_feature.__class__).get_abs_class_based_for_vdevice()[cur_setup_feature_vdevice]
+                feat_cnn = FeatureController.get_for(cur_setup_feature.__class__)\
+                    .get_abs_class_based_for_vdevice()[vdev_mappings_of_setup_feature[0].vdevice]
                 # connection that are relevant for this feature
                 relevant_cnns = [
                     cnn for cnn in abs_var_scenario_device_cnns
-                    if cnn.has_connection_from_to(cur_scenario_device, end_device=cur_mapped_scenario_device)
+                    if (cnn.has_connection_from_to(cur_scenario_device, end_device=cur_mapped_scenario_device)
+                        and max(single_feat_cnn.contained_in(cnn, ignore_metadata=True)
+                                for single_feat_cnn in feat_cnn.get_singles())
+                        )
                 ]
 
-                relevant_device_cnn = None
-
                 if len(relevant_cnns) > 1:
-                    # we have parallel possibilities -> determine the selected one (only one is allowed to fit)
-                    for cur_relevant_cnn in relevant_cnns:
-                        for cur_relevant_single_cnn, cur_feature_single_cnn in (
-                                itertools.product(cur_relevant_cnn.get_singles(), feature_cnn.get_singles())):
-                            if not cur_feature_single_cnn.contained_in(cur_relevant_single_cnn, ignore_metadata=True):
-                                continue
-                            if relevant_device_cnn is not None:
-                                raise UnclearAssignableFeatureConnectionError(
-                                    f"the devices {cur_scenario_device.__name__} and "
-                                    f"{cur_mapped_scenario_device.__name__} have multiple parallel connections - the "
-                                    f"device `{cur_scenario_device.__name__}` uses a feature "
-                                    f"`{cur_scenario_feature.__class__.__name__}` that matches with the device "
-                                    f"`{cur_mapped_scenario_device.__name__}`, but it is not clear which of the "
-                                    f"parallel connection could be used"
-                                )
-                            relevant_device_cnn = cur_relevant_cnn
-                elif len(relevant_cnns) == 1:
-                    relevant_device_cnn = relevant_cnns[0]
-                if relevant_device_cnn is None:
+                    raise UnclearAssignableFeatureConnectionError(
+                        f"the devices {cur_scenario_device.__name__} and {cur_mapped_scenario_device.__name__} have "
+                        f"multiple parallel connections - the device `{cur_scenario_device.__name__}` uses a feature "
+                        f"`{cur_scenario_feature.__class__.__name__}` that matches with the device "
+                        f"`{cur_mapped_scenario_device.__name__}`, but it is not clear which of the parallel "
+                        f"connection could be used")
+
+                if len(relevant_cnns) == 0:
                     # todo this does not map here
                     raise ValueError("can not find matching connection on scenario level")
 
+                relevant_device_cnn = relevant_cnns[0]
+
                 # now cleanup the scenario-device connection `relevant_device_cnn` according to the class-based feature
                 # connection
                 new_cnn_to_replace = Connection.based_on(OrConnectionRelation(*[
                     cur_old_cnn_single for cur_old_cnn_single in relevant_device_cnn.get_singles()
-                    if feature_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True)
+                    if feat_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True)
                 ]))
                 new_cnn_to_replace.set_metadata_for_all_subitems(relevant_device_cnn.metadata)
 

baldertest-0.1.0b12/src/_balder/feature_replacement_mapping.py

@@ -0,0 +1,69 @@
+from typing import Union
+import dataclasses
+from .feature import Feature
+
+
+class FeatureReplacementMapping:
+    """
+    helper object that stores mappings between scenario and setup features - is used in :class:`VariationExecutor`
+    """
+
+    @dataclasses.dataclass
+    class FeatureMapping:
+        """
+        stores a single mapping
+        """
+        #: the feature attribute name in scenario device
+        attr_name: str
+        #: the scenario feature instance or None if the current variation does not use this setup feature in scenario
+        scenario_feature: Union[Feature, None]
+        #: the setup feature that is used for the scenario feature
+        setup_feature: Feature
+
+    def __init__(self):
+        self._mappings: list[FeatureReplacementMapping.FeatureMapping] = []
+
+    @property
+    def mappings(self) -> list[FeatureMapping]:
+        """
+        returns all existing mappings
+        """
+        return list(self._mappings)
+
+    @property
+    def attr_names(self) -> list[str]:
+        """
+        returns all used attribute names
+        """
+        return [mapping.attr_name for mapping in self._mappings]
+
+    def add(self, attr_name: str, scenario_feature: Union[Feature, None], setup_feature: Feature):
+        """
+        adds a new mapping
+
+        :param attr_name: the feature attribute name in scenario device
+        :param scenario_feature: the scenario feature instance or None if the current variation does not use this setup
+                                 feature in scenario
+        :param setup_feature: the setup feature that is used for the scenario feature
+        """
+        if attr_name in self.attr_names:
+            raise KeyError(f'entry for property name `{attr_name}` already exist - can not define it multiple times')
+        self._mappings.append(FeatureReplacementMapping.FeatureMapping(attr_name, scenario_feature, setup_feature))
+
+    def get_features_for_attr_name(self, attr_name: str) -> tuple[Feature, Feature]:
+        """
+        returns the scenario and its mapped setup feature for a specific attribute name used in the scenario device
+        """
+        for mapping in self._mappings:
+            if mapping.attr_name == attr_name:
+                return mapping.scenario_feature, mapping.setup_feature
+        raise KeyError(f'entry for property name `{attr_name}` does not exist')
+
+    def get_replaced_scenario_feature_for(self, setup_feature: Feature) -> Union[Feature, None]:
+        """
+        returns the mapped scenario feature for a given setup feature
+        """
+        for mapping in self._mappings:
+            if mapping.setup_feature == setup_feature:
+                return mapping.scenario_feature
+        raise KeyError(f'cannot find setup feature for {setup_feature}')

baldertest-0.1.0b12/src/_balder/feature_vdevice_mapping.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+from typing import Type
+import dataclasses
+
+from .controllers.feature_controller import FeatureController
+from .device import Device
+from .feature import Feature
+from .vdevice import VDevice
+
+
+class FeatureVDeviceMapping:
+    """
+    helper object that stores mappings between :class:`VDevice` and :class:`Device`
+    """
+
+    @dataclasses.dataclass
+    class VDeviceDeviceMapping:
+        """describes the mapping of one VDevice to one Device"""
+        #: the vdevice class
+        vdevice: Type[VDevice]
+        #: the mapped device to this VDevice
+        device: Type[Device]
+
+    @dataclasses.dataclass
+    class VDevicesMapping:
+        """
+        stores a single mapping
+        """
+        #: the feature object, this mapping belongs to
+        feature: Feature
+        #: the available mapping for this feature (at the moment, we only support one)
+        mappings: list[FeatureVDeviceMapping.VDeviceDeviceMapping]
+
+    def __init__(self):
+        self._mappings: list[FeatureVDeviceMapping.VDevicesMapping] = []
+
+    @property
+    def mappings(self) -> list[VDevicesMapping]:
+        """
+        returns all existing mappings
+        """
+        return list(self._mappings)
+
+    @property
+    def features(self) -> list[Feature]:
+        """
+        returns all used attribute names
+        """
+        return [mapping.feature for mapping in self._mappings]
+
+    def items(self) -> list[tuple[Feature, list[VDeviceDeviceMapping]]]:
+        """
+        :return: a list of Feature/vdevice mapping tuples
+        """
+        return [(mapping.feature, mapping.mappings) for mapping in self._mappings]
+
+    def add(self, feature: Feature, mappings: dict[Type[VDevice], Type[Device]]):
+        """
+        adds a new mapping
+
+        :param feature: the :class:`Feature` class this mapping belongs to
+        :param mappings: a dictionary that describes the mapping between the :class:`VDevice` and :class:`Device`. The
+                         :class:`VDevice` needs to be part of the :class:`Feature`
+        """
+        if feature in self.features:
+            raise KeyError(f'entry for feature `{feature}` already exist - can not define it multiple times')
+        feature_controller = FeatureController.get_for(feature.__class__)
+        vdevice_device_mappings = []
+        for cur_vdev, cur_dev in mappings.items():
+            if not (isinstance(cur_vdev, type) and issubclass(cur_vdev, VDevice)):
+                raise TypeError(f'the provided key objects in mappings needs to be a subclass of `{VDevice.__name__}`')
+            if not (isinstance(cur_dev, type) and issubclass(cur_dev, Device)):
+                raise TypeError(f'the provided value objects in mappings needs to be a subclass of `{Device.__name__}`')
+            if cur_vdev not in feature_controller.get_abs_inner_vdevice_classes():
+                raise ValueError(f'the provided VDevice `{cur_vdev}` is not part of the provided feature `{feature}`')
+            vdevice_device_mappings.append(self.VDeviceDeviceMapping(cur_vdev, cur_dev))
+        new_mapping = self.VDevicesMapping(feature=feature, mappings=vdevice_device_mappings)
+
+        self._mappings.append(new_mapping)
+
+    def get_mappings_for_feature(self, feature: Feature) -> list[VDeviceDeviceMapping]:
+        """
+        returns the list with all mappings for the provided feature
+        """
+        for cur_item in self._mappings:
+            if cur_item.feature == feature:
+                return cur_item.mappings
+        raise KeyError(f'entry for feature `{feature}` does not exist')

{baldertest-0.1.0b11 → baldertest-0.1.0b12}/src/_balder/routing_path.py

@@ -96,12 +96,15 @@ class RoutingPath:
         for cur_from_setup_node_conn in setup_devices_cnns:
             # only if there is a connection outgoing from `from_setup_device`
             if cur_from_setup_node_conn.has_connection_from_to(start_device=from_setup_device):
-                cur_from_setup_node = cur_from_setup_node_conn.from_node_name \
-                    if cur_from_setup_node_conn.from_device == from_setup_device \
-                    else cur_from_setup_node_conn.to_node_name
-                new_route = RoutingPath(cur_from_setup_node_conn, start_device=from_setup_device,
-                                        start_node_name=cur_from_setup_node)
-                all_possible_routes.append(new_route)
+                all_possible_routes.append(
+                    RoutingPath(
+                        cur_from_setup_node_conn,
+                        start_device=from_setup_device,
+                        start_node_name=(cur_from_setup_node_conn.from_node_name
+                                         if cur_from_setup_node_conn.from_device == from_setup_device
+                                         else cur_from_setup_node_conn.to_node_name)
+                    )
+                )
         # now go through every possibility and add them - filter all Routes that ``has_loop() == True`` or
         # are completed
         while len(all_possible_routes) > 0: