baldertest 0.1.0b10__py3-none-any.whl → 0.1.0b11__py3-none-any.whl

_balder/controllers/scenario_controller.py

@@ -4,6 +4,7 @@ from typing import Type, Dict, List, Tuple, Union, Callable, Iterable, Any
 import logging
 import inspect
 from collections import OrderedDict
+from _balder.cnnrelations import OrConnectionRelation
 from _balder.device import Device
 from _balder.scenario import Scenario
 from _balder.connection import Connection
@@ -215,15 +216,15 @@ class ScenarioController(NormalScenarioSetupController):
 
                 # now check if one or more single of the classbased connection are CONTAINED IN the possible
                 # parallel connection (only if there exists more than one parallel)
-                feature_cnn = Connection.based_on(*FeatureController.get_for(
-                        cur_feature.__class__).get_abs_class_based_for_vdevice()[mapped_vdevice])
+                feature_cnn = FeatureController.get_for(
+                    cur_feature.__class__).get_abs_class_based_for_vdevice()[mapped_vdevice]
 
                 # search node names that is the relevant connection
                 relevant_cnns: List[Connection] = []
                 mapped_device_abs_cnns = DeviceController.get_for(mapped_device).get_all_absolute_connections()
                 for _, all_connections in mapped_device_abs_cnns.items():
                     relevant_cnns += [cur_cnn for cur_cnn in all_connections
-                                      if cur_cnn.has_connection_from_to(cur_from_device, mapped_device)]
+                                      if cur_cnn.has_connection_from_to(cur_from_device, end_device=mapped_device)]
 
                 if len(relevant_cnns) <= 1:
                     # ignore if there are not more than one relevant connection
@@ -338,10 +339,9 @@ class ScenarioController(NormalScenarioSetupController):
                     continue
 
                 # now try to reduce the scenario connections according to the requirements of the feature class
-                cur_feature_class_based_for_vdevice = \
+                cur_feature_cnn = \
                     FeatureController.get_for(
                         cur_feature.__class__).get_abs_class_based_for_vdevice()[mapped_vdevice]
-                cur_feature_cnn = Connection.based_on(*cur_feature_class_based_for_vdevice)
 
                 device_cnn_singles = get_single_cnns_between_device_for_feature(
                     from_device=cur_from_device, to_device=mapped_device, relevant_feature_cnn=cur_feature_cnn)
@@ -395,7 +395,7 @@ class ScenarioController(NormalScenarioSetupController):
                         cur_from_device_controller = DeviceController.get_for(cur_from_device)
                         cur_to_device_controller = DeviceController.get_for(cur_to_device)
 
-                        new_cnn = Connection.based_on(*cur_single_cnns)
+                        new_cnn = Connection.based_on(OrConnectionRelation(*cur_single_cnns))
                         new_cnn.set_metadata_for_all_subitems(cur_single_cnns[0].metadata)
                         if cur_from_device == cur_single_cnns[0].from_device:
                             cur_from_device_controller.add_new_absolute_connection(new_cnn)

_balder/controllers/setup_controller.py

@@ -3,7 +3,6 @@ from typing import Type, Dict, Union, TYPE_CHECKING
 
 import logging
 from _balder.setup import Setup
-from _balder.connection import Connection
 from _balder.exceptions import IllegalVDeviceMappingError, MultiInheritanceError
 from _balder.controllers.feature_controller import FeatureController
 from _balder.controllers.device_controller import DeviceController
@@ -113,12 +112,12 @@ class SetupController(NormalScenarioSetupController):
                     continue
 
                 # there exists a class based requirement for this vDevice
-                class_based_cnn = Connection.based_on(*feature_class_based_for_vdevice[mapped_vdevice])
+                class_based_cnn = feature_class_based_for_vdevice[mapped_vdevice]
                 # search relevant connection
                 cur_device_controller = DeviceController.get_for(cur_device)
                 for _, cur_cnn_list in cur_device_controller.get_all_absolute_connections().items():
                     for cur_cnn in cur_cnn_list:
-                        if not cur_cnn.has_connection_from_to(cur_device, mapped_device):
+                        if not cur_cnn.has_connection_from_to(cur_device, end_device=mapped_device):
                             # this connection can be ignored, because it is no connection between the current device
                             # and the mapped device
                             continue

_balder/decorator_connect.py

@@ -5,10 +5,15 @@ import re
 from _balder.device import Device
 from _balder.connection import Connection
 from _balder.controllers import DeviceController
+from _balder.cnnrelations import AndConnectionRelation, OrConnectionRelation
 
 
-def connect(with_device: Union[Type[Device], str], over_connection: Union[Type[Connection], Connection],
-            self_node_name: str = None, dest_node_name: str = None):
+def connect(
+        with_device: Union[Type[Device], str],
+        over_connection: Union[Connection, Type[Connection], AndConnectionRelation, OrConnectionRelation],
+        self_node_name: str = None,
+        dest_node_name: str = None
+):
     """
     This decorator connects two devices with each other. It can be used for scenarios as well as setup devices.
 
@@ -27,11 +32,6 @@ def connect(with_device: Union[Type[Device], str], over_connection: Union[Type[C
     if not isinstance(with_device, str) and not issubclass(with_device, Device):
         raise ValueError("the value of `with_device` must be a `Device` (or a subclass thereof) or the device name "
                          "as a string")
-    if isinstance(over_connection, tuple):
-        # doesn't make sense, because we can describe what's needed in one scenario with several `@connect` decorations
-        # anyway. We are describing a setup, therefore an AND link makes no sense here either
-        raise TypeError("an AND link (signaled via the tuple) of the connection is not possible here - for further "
-                        "separate connections use the `@connect` decorator again")
     if isinstance(over_connection, type):
         if not issubclass(over_connection, Connection):
             raise TypeError("the type of `over_connection` must be a `Connection` (or a subclass of it)")
@@ -91,11 +91,13 @@ def connect(with_device: Union[Type[Device], str], over_connection: Union[Type[C
                 #  in another `@connect()` decorator (and also remove possible metadata from the new clone)
                 cur_cnn_instance = over_connection.clone()
                 cur_cnn_instance.set_metadata_for_all_subitems(None)
-            elif issubclass(over_connection, Connection):
+            elif isinstance(over_connection, type) and issubclass(over_connection, Connection):
                 # not instantiated -> instantiate it
                 cur_cnn_instance = over_connection()
-            cur_cnn_instance.set_devices(from_device=decorated_cls, to_device=with_device)
-            cur_cnn_instance.update_node_names(from_device_node_name=self_node_name, to_device_node_name=dest_node_name)
+            elif isinstance(over_connection, (AndConnectionRelation, OrConnectionRelation)):
+                over_connection = Connection.based_on(over_connection)
+            cur_cnn_instance.metadata.set_from(from_device=decorated_cls, from_device_node_name=self_node_name)
+            cur_cnn_instance.metadata.set_to(to_device=with_device, to_device_node_name=dest_node_name)
 
             decorated_cls_device_controller.add_new_raw_connection(cur_cnn_instance)
             return decorated_cls

_balder/decorator_for_vdevice.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
-from typing import List, Union, Type, Tuple
+from typing import Union, Type
 
 import inspect
+from _balder.cnnrelations import AndConnectionRelation, OrConnectionRelation
 from _balder.collector import Collector
 from _balder.feature import Feature
 from _balder.vdevice import VDevice
@@ -13,9 +14,9 @@ from _balder.exceptions import DuplicateForVDeviceError, UnknownVDeviceException
 def for_vdevice(
         vdevice: Union[str, Type[VDevice]],
         with_connections: Union[
-            Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]],
-            List[Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]]]]] = Connection(),
-                ):
+            Type[Connection], Connection, AndConnectionRelation, OrConnectionRelation
+        ] = Connection(),
+):
     """
     With the `@for_vdevice` you can limit the decorated object for a special allowed connection tree for every existing
     vDevice. This decorator can be used to decorate whole :class:`Feature` classes just like single methods of a
@@ -37,26 +38,18 @@ def for_vdevice(
 
     :param with_connections: the assigned connection trees for this class/method (default: a universal connection)
     """
-    idx = 0
-    if not isinstance(with_connections, list):
-        with_connections = [with_connections]
-    for cur_conn in with_connections:
-        if isinstance(cur_conn, type):
-            if not issubclass(cur_conn, Connection):
-                raise ValueError(f"the given element type for the element on position `{idx}` has to be a subclass of "
-                                 f"`{Connection.__name__}` or a element of it")
-        elif isinstance(cur_conn, tuple):
-            tuple_idx = 0
-            for cur_tuple_elem in cur_conn:
-                if not isinstance(cur_tuple_elem, Connection) and not issubclass(cur_tuple_elem, Connection):
-                    raise ValueError(f"the given tuple element `{tuple_idx}` that is given on position `{idx}` "
-                                     f"has to be a subclass of `{Connection.__name__}`")
-                tuple_idx += 1
-        elif not isinstance(cur_conn, Connection):
-            raise ValueError(f"the given type on position `{idx}` has to be a subclass of `{Connection.__name__}` or "
-                             f"a element of it")
-
-        idx += 1
+    if isinstance(with_connections, Connection):
+        # do nothing
+        pass
+    elif isinstance(with_connections, (AndConnectionRelation, OrConnectionRelation)):
+        # use container connection
+        with_connections = Connection.based_on(with_connections)
+    elif isinstance(with_connections, type) and issubclass(with_connections, Connection):
+        # instantiate it
+        with_connections = with_connections()
+    else:
+        raise TypeError(f"the given element ``with_connection`` needs to be from type `AndConnectionRelation`, "
+                        f"`OrConnectionRelation` or `Connection` - `{type(with_connections)}` is not allowed")
 
     # note: if `args` is an empty list - no special sub-connection-tree bindings
 
@@ -105,7 +98,6 @@ def for_vdevice(
 
                     vdevice = relevant_vdevices[0]
                 cls_for_vdevice = fn_feature_controller.get_class_based_for_vdevice()
-                cls_for_vdevice = {} if cls_for_vdevice is None else cls_for_vdevice
                 if vdevice in cls_for_vdevice.keys():
                     raise DuplicateForVDeviceError(
                         f'there already exists a decorator for the vDevice `{vdevice}` in the Feature class '

_balder/decorator_gateway.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from _balder.controllers.device_controller import DeviceController
 from _balder.device import Device
 from _balder.node_gateway import NodeGateway
 
@@ -25,10 +26,9 @@ def gateway(from_node: str, to_node: str, bidirectional: bool = True):
             raise TypeError(
                 f"The decorator `gateway` may only be used for `Device` objects. This is not possible for the applied "
                 f"class `{cls.__name__}`.")
+        decorated_cls_device_controller = DeviceController.get_for(cls)
 
-        if not hasattr(cls, '_gateways'):
-            cls._gateways = []
         new_gateway = NodeGateway(cls, from_node, to_node, bidirectional)
-        cls._gateways.append(new_gateway)
+        decorated_cls_device_controller.add_new_raw_gateway(new_gateway)
         return cls
     return decorator

_balder/executor/testcase_executor.py

@@ -12,7 +12,6 @@ from _balder.testresult import ResultState, TestcaseResult
 from _balder.utils import inspect_method
 
 if TYPE_CHECKING:
-    from _balder.executor.unresolved_parametrized_testcase_executor import UnresolvedParametrizedTestcaseExecutor
     from _balder.executor.variation_executor import VariationExecutor
     from _balder.fixture_manager import FixtureManager
     from _balder.scenario import Scenario

_balder/executor/variation_executor.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+
+import itertools
 from typing import Type, Union, List, Dict, Tuple, TYPE_CHECKING
 
 import inspect
 import logging
+from _balder.cnnrelations import OrConnectionRelation
 from _balder.device import Device
 from _balder.connection import Connection
 from _balder.fixture_execution_level import FixtureExecutionLevel
@@ -21,6 +24,8 @@ if TYPE_CHECKING:
     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
     from _balder.fixture_manager import FixtureManager
 
@@ -96,11 +101,25 @@ class VariationExecutor(BasicExecutableExecutor):
         """property returns the current :class:`Scenario` for this variation"""
         return self._parent_executor.base_scenario_class
 
+    @property
+    def cur_scenario_controller(self) -> ScenarioController:
+        """
+        returns the current :class:`ScenarioController` for this variation
+        """
+        return self._parent_executor.base_scenario_controller
+
     @property
     def cur_setup_class(self) -> Setup:
         """property returns the current :class:`Setup` for this variation"""
         return self._parent_executor.parent_executor.base_setup_class
 
+    @property
+    def cur_setup_controller(self) -> SetupController:
+        """
+        returns the current :class:`SetupController` for this variation
+        """
+        return self._parent_executor.parent_executor.base_setup_controller
+
     @property
     def base_device_mapping(self) -> Dict[Type[Device], Type[Device]]:
         """
@@ -284,6 +303,39 @@ class VariationExecutor(BasicExecutableExecutor):
                     f'can not find a valid routing on setup level for the connection `{scenario_cnn.get_tree_str()}` '
                     f'between scenario devices `{scenario_cnn.from_device}` and `{scenario_cnn.to_device}`')
 
+    def _get_matching_setup_features_for(
+            self,
+            scenario_feature_obj: Feature,
+            in_setup_device: Type[Device]
+    ) -> List[Feature]:
+        """
+        Helper method that returns all matching setup features for the provided scenario feature in the provided setup
+        device.
+        """
+        cur_setup_features = DeviceController.get_for(in_setup_device).get_all_instantiated_feature_objects()
+
+        replacing_feature_candidates = [
+            cur_setup_feature for cur_setup_feature in cur_setup_features.values()
+            if isinstance(cur_setup_feature, scenario_feature_obj.__class__)
+        ]
+        active_scenario_vdev, mapped_scenario_dev = scenario_feature_obj.active_vdevice_device_mapping
+
+        replacing_features = replacing_feature_candidates.copy()
+        if mapped_scenario_dev is not None:
+            # get the related setup device for the mapped scenario device (on scenario level)
+            setup_dev_of_mapped_scenario_dev = self.get_setup_device_for(mapped_scenario_dev)
+
+            # now check if there is a mapping on setup level too
+            for cur_replacing_feature in replacing_feature_candidates:
+                mapped_setup_vdev, mapped_setup_dev = cur_replacing_feature.active_vdevice_device_mapping
+                if mapped_setup_vdev is not None and not issubclass(mapped_setup_vdev, active_scenario_vdev):
+                    # drop this feature matching, because we have different vdevice mapped
+                    replacing_features.remove(cur_replacing_feature)
+                elif mapped_setup_dev is not None and mapped_setup_dev != setup_dev_of_mapped_scenario_dev:
+                    # drop this feature matching, because it is not applicable here
+                    replacing_features.remove(cur_replacing_feature)
+        return replacing_features
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def testsummary(self) -> ResultSummary:
@@ -336,75 +388,53 @@ 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 = {}
-        abs_setup_vdevice_mappings = {}
+        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()}
         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()
 
-            if cur_scenario_device not in feature_replacement.keys():
-                feature_replacement[cur_scenario_device] = {}
-
-            if cur_setup_device not in abs_setup_vdevice_mappings.keys():
-                abs_setup_vdevice_mappings[cur_setup_device] = {}
-
             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_abstract_scenario_feature_obj in cur_scenario_device_orig_features.items():
-                replacing_features = [cur_setup_feature for _, cur_setup_feature in cur_setup_features.items()
-                                      if isinstance(cur_setup_feature, cur_abstract_scenario_feature_obj.__class__)]
-                used_scenario_vdevice, mapped_scenario_device = \
-                    cur_abstract_scenario_feature_obj.active_vdevice_device_mapping
-                # check if there is a mapped device in scenario level
-                cleanup_replacing_features = replacing_features.copy()
-                if mapped_scenario_device is not None:
-                    # get the related setup device for the mapped scenario device (on scenario level)
-                    to_scenarios_vdevice_mapped_setup_device = self.get_setup_device_for(mapped_scenario_device)
-
-                    # now check if there is a mapping on setup level too
-                    for cur_replacing_feature in replacing_features:
-                        mapped_setup_vdevice, mapped_setup_device = cur_replacing_feature.active_vdevice_device_mapping
-                        if mapped_setup_vdevice is not None and \
-                                not issubclass(mapped_setup_vdevice, used_scenario_vdevice):
-                            # drop this feature matching, because we have different vdevice mapped
-                            cleanup_replacing_features.remove(cur_replacing_feature)
-                        elif mapped_setup_device is not None and \
-                                mapped_setup_device != to_scenarios_vdevice_mapped_setup_device:
-                            # drop this feature matching, because it is not applicable here
-                            cleanup_replacing_features.remove(cur_replacing_feature)
-
-                if len(cleanup_replacing_features) != 1:
+            for cur_attr_name, cur_scenario_feature_obj in cur_scenario_device_orig_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(
+                    scenario_feature_obj=cur_scenario_feature_obj, in_setup_device=cur_setup_device
+                )
+
+                if len(cur_setup_feature_objs) != 1:
                     raise NotApplicableVariationException(
                         f'this variation can not be applicable because there was no setup feature implementation of '
-                        f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
+                        f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                         f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
+                cur_setup_feature_obj = cur_setup_feature_objs[0]
 
                 if mapped_scenario_device is None:
                     # we have exactly one matching candidate, but also no vDevice mapping
                     # check if the matching candidate has a vDevice mapping
-                    _, mapped_setup_device = cleanup_replacing_features[0].active_vdevice_device_mapping
-                    cleanup_feature_controller = FeatureController.get_for(cleanup_replacing_features[0].__class__)
+                    _, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
+                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
                     if mapped_setup_device is None \
                             and len(cleanup_feature_controller.get_abs_inner_vdevice_classes()) > 0:
                         # there is no vDevice mapping on scenario and no vDevice mapping on setup level, but the
                         # feature defined vDevices -> NOT APPLICABLE
                         logger.warning(
                             f"missing vDevice mapping for feature "
-                            f"`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used in scenario device "
+                            f"`{cur_scenario_feature_obj.__class__.__name__}` (used in scenario device "
                             f"`{cur_scenario_device.__name__}` and in setup device `{cur_setup_device.__name__}`) - "
                             f"VARIATION CAN NOT BE APPLIED")
                         raise NotApplicableVariationException(
-                            f'this variation can not be applicable because there was no vDevice mapping given on '
+                            f'this variation can not be applied because there was no vDevice mapping given on '
                             f'scenario or on setup level for the feature '
-                            f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
+                            f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                             f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
 
-                all_assigned_setup_features.append(cleanup_replacing_features[0])
+                all_assigned_setup_features.append(cur_setup_feature_obj)
                 if cur_attr_name not in feature_replacement[cur_scenario_device].keys():
-                    cleanup_feature = cleanup_replacing_features[0]
-                    cleanup_feature_controller = FeatureController.get_for(cleanup_feature.__class__)
+                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
 
-                    used_setup_vdevice, mapped_setup_device = cleanup_feature.active_vdevice_device_mapping
+                    used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
 
                     # if there is a vDevice mapping on scenario level, but not on setup level, so update the
                     # VDevice-Device-Mapping there
@@ -413,21 +443,21 @@ class VariationExecutor(BasicExecutableExecutor):
                         # because check was already done in collector-stage)
                         setup_vdevices = [cur_vdevice for cur_vdevice
                                           in cleanup_feature_controller.get_abs_inner_vdevice_classes()
-                                          if cur_vdevice.__name__ == used_scenario_vdevice.__name__]
+                                          if cur_vdevice.__name__ == active_scenario_vdevice.__name__]
                         used_setup_vdevice = setup_vdevices[0]
                         # set the mapping
-                        abs_setup_vdevice_mappings[cur_setup_device][cleanup_feature] = {
+                        abs_setup_vdevice_mappings[cur_setup_device][cur_setup_feature_obj] = {
                             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][cleanup_feature] = {
+                        abs_setup_vdevice_mappings[cur_setup_device][cur_setup_feature_obj] = {
                             used_setup_vdevice: mapped_setup_device}
 
                     feature_replacement[cur_scenario_device][cur_attr_name] = \
-                        (cur_abstract_scenario_feature_obj, cleanup_feature)
+                        (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.items():
+            for cur_setup_feature in cur_setup_features.values():
                 if cur_setup_feature not in all_assigned_setup_features:
                     # determine free name
                     idx = 0
@@ -679,31 +709,16 @@ class VariationExecutor(BasicExecutableExecutor):
 
     def determine_absolute_scenario_device_connections(self):
         """
-        This method determines the variation absolute connections for this variation and sets them to the internal
-        properties `_abs_variation_*_device_connections`. This will be used to determine the real connection-subtree
+        This method determines the absolute connections for this variation and sets the internal properties
+        `_abs_variation_*_device_connections` with them. This will be used to determine the real connection-subtree
         (that can be used for this variation) by the method `create_all_valid_routings()`.
 
         The method re-executes the algorithm to determine the absolute connections for a scenario/setup (see the method
         :meth:`Collector.determine_absolute_device_connections_for`), but it considers the real applied vDevice and
         their feature restrictions too.
         """
-        abs_var_scenario_device_cnns = {}
-
         # first determine all relevant absolute connection depending on the current scenario
-        for cur_scenario_device, _ in self.base_device_mapping.items():
-            cur_scenario_device_abs_cnns = \
-                DeviceController.get_for(cur_scenario_device).get_all_absolute_connections()
-            for _, cur_cnn_list in cur_scenario_device_abs_cnns.items():
-                for cur_cnn in cur_cnn_list:
-                    if cur_scenario_device not in abs_var_scenario_device_cnns.keys():
-                        abs_var_scenario_device_cnns[cur_scenario_device] = {}
-
-                    cur_to_device, _ = cur_cnn.get_conn_partner_of(cur_scenario_device)
-
-                    if cur_to_device not in abs_var_scenario_device_cnns[cur_scenario_device].keys():
-                        abs_var_scenario_device_cnns[cur_scenario_device][cur_to_device] = []
-
-                    abs_var_scenario_device_cnns[cur_scenario_device][cur_to_device].append(cur_cnn)
+        abs_var_scenario_device_cnns = self.cur_scenario_controller.get_all_abs_connections()
 
         # 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)
@@ -726,31 +741,34 @@ class VariationExecutor(BasicExecutableExecutor):
 
                 # get relevant class based connections for the current feature on setup level (this is really be used
                 # here)
-                feature_cnns = \
+                feature_cnn = \
                     FeatureController.get_for(
                         cur_setup_feature.__class__).get_abs_class_based_for_vdevice()[cur_setup_feature_vdevice]
                 # connection that are relevant for this feature
-                relevant_cnns = abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device]
+                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)
+                ]
 
                 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 in cur_relevant_cnn.get_singles():
-                            for cur_feature_cnn in feature_cnns:
-                                for cur_feature_single_cnn in cur_feature_cnn.get_singles():
-                                    if cur_feature_single_cnn.contained_in(cur_relevant_single_cnn):
-                                        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 "
-                                                f"connections - the device `{cur_scenario_device.__name__}` uses a "
-                                                f"feature `{cur_scenario_feature.__class__.__name__}` that matches "
-                                                f"with the device `{cur_mapped_scenario_device.__name__}`, but it is "
-                                                f"not clear which of the parallel connection could be used"
-                                            )
-                                        relevant_device_cnn = cur_relevant_cnn
+                        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:
@@ -759,36 +777,19 @@ class VariationExecutor(BasicExecutableExecutor):
 
                 # now cleanup the scenario-device connection `relevant_device_cnn` according to the class-based feature
                 # connection
-                new_cleaned_singles = []
-                for cur_old_cnn_single in relevant_device_cnn.get_singles():
-                    for cur_feature_cnn in feature_cnns:
-                        if cur_feature_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True):
-                            new_cleaned_singles.append(cur_old_cnn_single)
-
-                new_cnn_to_replace = Connection.based_on(*new_cleaned_singles)
-                new_cnn_to_replace.set_metadata_for_all_subitems(new_cleaned_singles[0].metadata)
-
-                abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device].remove(
-                    relevant_device_cnn)
-                abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device].append(new_cnn_to_replace)
-
-                # also search the connection in the other direction
-                other_dir_relevant_device_cnn = None
-                for cur_cnn in abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device]:
-                    if cur_cnn.equal_with(relevant_device_cnn):
-                        other_dir_relevant_device_cnn = cur_cnn
-                        break
-                # and also replace it
-                abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device].remove(
-                    other_dir_relevant_device_cnn)
-                abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device].append(new_cnn_to_replace)
+                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)
+                ]))
+                new_cnn_to_replace.set_metadata_for_all_subitems(relevant_device_cnn.metadata)
+
+                abs_var_scenario_device_cnns.remove(relevant_device_cnn)
+                abs_var_scenario_device_cnns.append(new_cnn_to_replace)
+
+                # we do not need to check other direction because `has_connection_from_to()` returns both possibilities
 
         # set the determined values in variation object
-        self._abs_variation_scenario_device_connections = []
-        for _, from_device_dict in abs_var_scenario_device_cnns.items():
-            for _, cur_cnn_list in from_device_dict.items():
-                for cur_cnn in cur_cnn_list:
-                    self._abs_variation_scenario_device_connections.append(cur_cnn)
+        self._abs_variation_scenario_device_connections = abs_var_scenario_device_cnns
 
     def create_all_valid_routings(self):
         """
@@ -828,16 +829,18 @@ class VariationExecutor(BasicExecutableExecutor):
                 if virtual_routing_cnns[cur_cnn] is None:
                     virtual_routing_cnns[cur_cnn] = Connection.based_on(virtual_cnn)
                 else:
-                    virtual_routing_cnns[cur_cnn] = Connection.based_on(virtual_routing_cnns[cur_cnn], virtual_cnn)
+                    virtual_routing_cnns[cur_cnn] = Connection.based_on(
+                        OrConnectionRelation(virtual_routing_cnns[cur_cnn], virtual_cnn))
                 virtual_routing_cnns[cur_cnn].set_metadata_for_all_subitems(virtual_cnn.metadata)
 
         self._abs_variation_connections = []
         for cur_cnn in self._abs_variation_scenario_device_connections:
             cur_virtual_cnn = virtual_routing_cnns[cur_cnn]
             new_intersection = cur_cnn.intersection_with(cur_virtual_cnn)
-            new_intersection.set_metadata_for_all_subitems(None)
-            # always set the metadata for setup devices
-            new_intersection.set_metadata_for_all_subitems(cur_virtual_cnn.metadata)
+            if new_intersection:
+                new_intersection.set_metadata_for_all_subitems(None)
+                # always set the metadata for setup devices
+                new_intersection.set_metadata_for_all_subitems(cur_virtual_cnn.metadata)
             self._abs_variation_connections.append(new_intersection)
 
     def set_conn_dependent_methods(self):
@@ -873,11 +876,15 @@ class VariationExecutor(BasicExecutableExecutor):
                     relevant_abs_conn = []
                     for cur_cnn in self._abs_variation_connections:
                         if cur_cnn.has_connection_from_to(start_device=setup_device, end_device=mapped_setup_device):
-                            relevant_abs_conn.append(cur_cnn)
+                            # add the children
+                            relevant_abs_conn.extend(
+                                cur_cnn.based_on_elements.connections if cur_cnn.__class__ == Connection else [cur_cnn]
+                            )
+
                     if len(relevant_abs_conn) is None:
                         raise RuntimeError(f"detect empty absolute connection between device `{setup_device.__name__}` "
                                            f"and device `{mapped_setup_device.__name__}`")
-                    absolute_feature_method_var_cnn = Connection.based_on(*relevant_abs_conn)
+                    absolute_feature_method_var_cnn = Connection.based_on(OrConnectionRelation(*relevant_abs_conn))
                     cur_method_variation = cur_setup_feature_controller.get_method_variation(
                         of_method_name=cur_method_name, for_vdevice=mapped_vdevice,
                         with_connection=absolute_feature_method_var_cnn)

_balder/feature.py

@@ -16,7 +16,7 @@ class Feature:
         :param kwargs: contains a dictionary that references all vDevices of the feature and a real
                         scenario :meth:`Device` as value
         """
-        from _balder.controllers import FeatureController
+        from _balder.controllers import FeatureController  # pylint: disable=import-outside-toplevel
 
         #: this property contains the active mapping for the devices
         self.active_vdevices: Dict[VDevice, Union[Device, str]] = {}