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

_balder/connection_metadata.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+from typing import Union, Type, Tuple
+from .device import Device
+
+
+class ConnectionMetadata:
+    """
+    Describes the metadata of a connection.
+    """
+
+    def __init__(
+            self,
+            from_device: Union[Type[Device], None] = None,
+            to_device: Union[Type[Device], None] = None,
+            from_device_node_name: Union[str, None] = None,
+            to_device_node_name: Union[str, None] = None,
+            bidirectional: bool = True,
+    ):
+
+        self._from_device = None
+        self._from_device_node_name = None
+        self.set_from(from_device, from_device_node_name)
+
+        self._to_device = None
+        self._to_device_node_name = None
+        self.set_to(to_device, to_device_node_name)
+
+        if not ((from_device is None and to_device is None and from_device_node_name is None
+                 and to_device_node_name is None) or (
+                from_device is not None and to_device is not None and from_device_node_name is not None and
+                to_device_node_name is not None)):
+            raise ValueError(
+                "you have to provide all or none of the following items: `from_device`, `from_device_node_name`, "
+                "`to_device` or `to_device_node_name`")
+
+        # describes if the connection is uni or bidirectional
+        self._bidirectional = bidirectional
+
+    def __eq__(self, other: ConnectionMetadata):
+        return self.equal_with(other)
+
+    def __hash__(self):
+        all_hashes = hash(self._from_device) + hash(self._to_device) + hash(self._from_device_node_name) + \
+                     hash(self._to_device_node_name) + hash(self._bidirectional)
+        return hash(all_hashes)
+
+    def __compare_with(self, other: ConnectionMetadata, allow_single_unidirectional_for_both_directions: bool) -> bool:
+        """
+        This method checks, if the metadata of this object is the metadata of the other object.
+
+        The method returns true in the following situations:
+        * both connections are bidirectional / the FROM and TO elements (device and node name) are the same
+        * both connections are bidirectional / the FROM is the TO and the TO is the FROM
+        * both connections are unidirectional and have the same from and to elements
+
+        If the parameter `allow_single_unidirectional_for_both_directions` is True, it additionally checks the following
+        situations:
+        * one is unidirectional / the other is bidirectional / the FROM and TO elements are the same
+        * one is unidirectional / the other is bidirectional / the FROM is the TO and the TO is the FROM
+        """
+        def check_same() -> bool:
+            return (self.from_device == other.from_device and self.from_node_name == other.from_node_name and
+                    self.to_device == other.to_device and self.to_node_name == other.to_node_name)
+
+        def check_twisted() -> bool:
+            return (self.from_device == other.to_device and self.from_node_name == other.to_node_name and
+                    self.to_device == other.from_device and self.to_node_name == other.from_node_name)
+
+        # CHECK: both connections are bidirectional / the FROM and TO elements (device and node name) are the same
+        # CHECK: both connections are bidirectional / the FROM is the TO and the TO is the FROM
+        if self.bidirectional and other.bidirectional:
+            return check_same() or check_twisted()
+        # CHECK: both connections are unidirectional and have the same from and to elements
+        if not self.bidirectional and not other.bidirectional:
+            return check_same()
+
+        if allow_single_unidirectional_for_both_directions:
+            # CHECK: one is unidirectional / the other is bidirectional / the FROM and TO elements are the same
+            # CHECK: one is unidirectional / the other is bidirectional / the FROM is the TO and the TO is the FROM
+            if self.bidirectional and not other.bidirectional or not self.bidirectional and other.bidirectional:
+                return check_same() or check_twisted()
+        return False
+
+    def set_from(self, from_device: Union[Type[Device], None], from_device_node_name: Union[str, None] = None):
+        """
+        This method sets the FROM device and node for this connection.
+
+        :param from_device: The FROM device of this connection.
+        :param from_device_node_name: The FROM node of this connection (if it should be set, otherwise None).
+        """
+        if from_device is not None and isinstance(from_device, type) and not issubclass(from_device, Device):
+            raise TypeError(f"detect illegal argument element {str(from_device)} for given attribute "
+                            f"`from_device` - should be a subclasses of `balder.Device`")
+        self._from_device = from_device
+
+        if from_device_node_name is not None and not isinstance(from_device_node_name, str):
+            raise TypeError(f"detect illegal argument type {type(from_device_node_name)} for given attribute "
+                            f"`from_device_node_name` - should be a string value")
+        self._from_device_node_name = from_device_node_name
+
+    def set_to(self, to_device: Union[Type[Device], None], to_device_node_name: Union[str, None] = None):
+        """
+        This method sets the TO device and node of this connection.
+
+        :param to_device: The TO device of this connection.
+        :param to_device_node_name: The TO node of this connection (if it should be set, otherwise None).
+        """
+        if to_device is not None and isinstance(to_device, type) and not issubclass(to_device, Device):
+            raise TypeError(f"detect illegal argument element {str(to_device)} for given attribute "
+                            f"`to_device` - should be a subclasses of `balder.Device`")
+        self._to_device = to_device
+
+        if to_device_node_name is not None and not isinstance(to_device_node_name, str):
+            raise TypeError(f"detect illegal argument type {type(to_device_node_name)} for given attribute "
+                            f"`to_device_node_name` - should be a string value")
+        self._to_device_node_name = to_device_node_name
+
+    def get_conn_partner_of(self, device: Type[Device], node: Union[str, None] = None) -> Tuple[Type[Device], str]:
+        """
+        This method returns the connection partner of this connection - it always returns the other not given side
+
+        :param device: the device itself - the other will be returned
+
+        :param node: the node name of the device itself (only required if the connection starts and ends with the same
+                     device)
+        """
+        if device not in (self.from_device, self.to_device):
+            raise ValueError(f"the given device `{device.__qualname__}` is no component of this connection")
+        if node is None:
+            # check that the from_device and to_device are not the same
+            if self.from_device == self.to_device:
+                raise ValueError("the connection is a inner-device connection (start and end is the same device) - you "
+                                 "have to provide the `node` string too")
+            if device == self.from_device:
+                return self.to_device, self.to_node_name
+
+            return self.from_device, self.from_node_name
+
+        if node not in (self.from_node_name, self.to_node_name):
+            raise ValueError(f"the given node `{node}` is no component of this connection")
+
+        if device == self.from_device and node == self.from_node_name:
+            return self.to_device, self.to_node_name
+
+        if device == self.to_device and node == self.to_node_name:
+            return self.from_device, self.from_node_name
+
+        raise ValueError(f"the given node `{node}` is no component of the given device `{device.__qualname__}`")
+
+    def has_connection_from_to(
+            self,
+            start_device: Type[Device],
+            start_device_node_name: Union[str, None] = None,
+            end_device: Union[Type[Device], None] = None,
+            end_device_node_name: Union[str, None] = None,
+    ) -> bool:
+        """
+        This method checks if there is a connection from ``start_device`` to ``end_device``. This will return
+        true if the ``start_device`` and ``end_device`` given in this method are also the ``start_device`` and
+        ``end_device`` mentioned in this connection object. If this is a bidirectional connection, ``start_device`` and
+        ``end_device`` can switch places.
+
+
+        :param start_device: the device for which the method should check whether it is a communication partner (for
+                             non-bidirectional connection, this has to be the start device)
+        :param start_device_node_name: the node name that start device should have or None if it should be ignored
+        :param end_device: the other device for which the method should check whether it is a communication partner (for
+                           non-bidirectional connection, this has to be the end device - this is optional if only the
+                           start device should be checked)
+        :param end_device_node_name: the node name that start device should have or None if it should be ignored
+
+        :return: returns true if the given direction is possible
+        """
+        if not (isinstance(start_device, type) and issubclass(start_device, Device)):
+            raise TypeError("argument `start_device` needs to be a device")
+        if not (start_device_node_name is None or isinstance(start_device_node_name, str)):
+            raise TypeError("argument `start_device_node_name` needs to be a string or None if it should be ignored")
+        if not (end_device is None or isinstance(end_device, type) and issubclass(end_device, Device)):
+            raise TypeError("argument `end_device` needs to be a device or None if it should be ignored")
+        if not (end_device_node_name is None or isinstance(end_device_node_name, str)):
+            raise TypeError("argument `end_device_node_name` needs to be a string or None if it should be ignored")
+
+        def check(start_dev, start_node_name, end_dev, end_node_name):
+            if start_device != start_dev:
+                return False
+            if start_device_node_name is not None and start_device_node_name != start_node_name:
+                return False
+            if end_device is not None and end_device != end_dev:
+                return False
+            if end_device_node_name is not None and end_device_node_name != end_node_name:
+                return False
+            return True
+
+        if self.bidirectional:
+            if check(start_dev=self.to_device, start_node_name=self.to_node_name,
+                     end_dev=self.from_device, end_node_name=self.from_node_name):
+                return True
+        return check(start_dev=self.from_device, start_node_name=self.from_node_name,
+                     end_dev=self.to_device, end_node_name=self.to_node_name)
+
+    def equal_with(self, other: ConnectionMetadata) -> bool:
+        """
+        This method returns true if the metadata of the current connection is equal with the metadata of the given
+        connection.
+
+        The method returns true in the following situations:
+        * both connections are bidirectional and the from and to elements (device and node name) are the same
+        * both connections are unidirectional and have the same from and to elements
+        * both connections are bidirectional and the from is the to and the to is the from
+
+        :return: true if the metadata of the current connection is contained in the metadata of the given one
+        """
+        return self.__compare_with(other, allow_single_unidirectional_for_both_directions=False)
+
+    def contained_in(self, other: ConnectionMetadata) -> bool:
+        """
+        This method returns true if the metadata of the current connection is contained in the given one.
+
+        The method returns true in the following situations:
+        * both connections are bidirectional and the from and to elements (device and node name) are the same
+        * both connections are unidirectional and have the same from and to elements
+        * both connections are bidirectional and the from is the to and the to is the from
+        * one connection is unidirectional and the other is bidirectional and the from and to elements are the same
+        * one connection is unidirectional and the other is bidirectional and the from is the to and the to is the from
+
+        :return: true if the metadata of the current connection is contained in the metadata of the given one
+        """
+        return self.__compare_with(other, allow_single_unidirectional_for_both_directions=True)
+
+    @property
+    def from_device(self):
+        """device from which the connection starts"""
+        return self._from_device
+
+    @property
+    def to_device(self):
+        """device at which the connection ends"""
+        return self._to_device
+
+    @property
+    def from_node_name(self):
+        """the name of the node in the `Device` from which the connection starts"""
+        return self._from_device_node_name
+
+    @property
+    def to_node_name(self):
+        """the name of the node in the `Device` at which the connection ends"""
+        return self._to_device_node_name
+
+    @property
+    def bidirectional(self) -> bool:
+        """
+        returns true if the connection is bidirectional (can go in both directions) otherwise false
+        """
+        return self._bidirectional

_balder/controllers/device_controller.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
-from typing import Dict, List, Type, Tuple, Union, TYPE_CHECKING
+
+import copy
+from typing import Dict, List, Type, Union, TYPE_CHECKING
 
 import sys
 import logging
@@ -16,6 +18,7 @@ from _balder.exceptions import DeviceScopeError, DeviceResolvingException, Inner
 if TYPE_CHECKING:
     from _balder.connection import Connection
     from _balder.controllers import ScenarioController, SetupController
+    from _balder.node_gateway import NodeGateway
 
 logger = logging.getLogger(__file__)
 
@@ -61,6 +64,8 @@ class DeviceController(BaseDeviceController, ABC):
         #: describes the absolute connections from the related device to another device
         self._absolute_connections: Dict[Type[Device], List[Connection]] = {}
 
+        self._gateways: List[NodeGateway] = []
+
     # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
 
     @staticmethod
@@ -146,6 +151,17 @@ class DeviceController(BaseDeviceController, ABC):
 
         self._connections[own_node].append(connection)
 
+    def add_new_raw_gateway(self, gateway: NodeGateway):
+        """
+        This method adds a new raw gateway to the internal property `_gateways`.
+
+        :param gateway: the gateway object (the related device has to be part of it)
+        """
+        if gateway.device != self.related_cls:
+            raise ValueError("the given gateway does not have the current device as component")
+
+        self._gateways.append(gateway)
+
     def add_new_absolute_connection(self, connection: Connection):
         """
         This method adds a new absolute connection to the internal property `absolute_connections`.
@@ -257,7 +273,7 @@ class DeviceController(BaseDeviceController, ABC):
     #     for cur_gateway in self._gateways:
     #         cur_gateway.validate_given_node_names()
 
-    def get_node_types(self) -> Dict[str, List[Connection, Tuple[Connection]]]:
+    def get_node_types(self) -> Dict[str, List[Connection | None]]:
         """
         This method returns a dictionary with the node name as key and a connection class as value. This class
         describes the common connection sub-tree, that all incoming and outgoing connections of the related device have
@@ -342,16 +358,16 @@ class DeviceController(BaseDeviceController, ABC):
                 if cur_conn.to_device in all_inner_classes_of_outer.keys():
                     meta = cur_conn.metadata
 
-                    meta["to_device"] = all_inner_classes_of_outer[cur_conn.to_device]
-                    if meta["to_device_node_name"] is None:
-                        # no unique node was given -> create one
-                        meta["to_device_node_name"] = \
-                            DeviceController.get_for(meta["to_device"]).get_new_empty_auto_node()
+                    to_device = all_inner_classes_of_outer[cur_conn.to_device]
+                    # if there was given no unique node -> create one
+                    to_device_node_name = DeviceController.get_for(to_device).get_new_empty_auto_node() \
+                        if meta.to_node_name is None else meta.to_node_name
+
+                    meta.set_to(
+                        to_device=to_device,
+                        to_device_node_name=to_device_node_name)
 
-                    # first reset whole metadata
-                    cur_conn.metadata = {}
-                    # now set metadata
-                    cur_conn.metadata = meta
+                    cur_conn.set_metadata_for_all_subitems(meta)
                 else:
                     raise DeviceResolvingException(
                         f"cannot resolve the str for the given device class `{cur_conn.to_device}` for "
@@ -429,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)
@@ -440,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

_balder/controllers/feature_controller.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+
+import copy
 from typing import Type, Dict, Union, List, Callable, Tuple
 
 import logging
 import inspect
+from _balder.cnnrelations import OrConnectionRelation
 from _balder.device import Device
 from _balder.vdevice import VDevice
 from _balder.feature import Feature
@@ -43,16 +46,16 @@ class FeatureController(Controller):
         self._related_cls = related_cls
 
         #: holds the defined **Class-Based-Binding** for the related feature class sorted by VDevice types
-        self._cls_for_vdevice: Dict[Type[VDevice], List[Connection, Type[Connection]]] = {}
+        self._cls_for_vdevice: Dict[Type[VDevice], Connection] = {}
 
         #: holds the absolute calculated **Class-Based-Binding** for the related feature class sorted by VDevice types
         #: (will be calculated by :meth:`FeatureController.determine_absolute_class_based_for_vdevice`, which will be
         #: called during collecting)
-        self._abs_cls_for_vdevice: Union[Dict[Type[VDevice], List[Connection]], None] = None
+        self._abs_cls_for_vdevice: Union[Dict[Type[VDevice], Connection], None] = None
 
         #: contains the **Method-Based-Binding** information for the current feature type (will be automatically set by
         #: executor)
-        self._for_vdevice: Union[Dict[str, Dict[Callable, Dict[Type[VDevice], List[Connection]]]], None] = None
+        self._for_vdevice: Union[Dict[str, Dict[Callable, Dict[Type[VDevice], Connection]]], None] = None
 
         #: contains the original defined :class:`VDevice` objects for this feature (will be automatically set by
         #:  :class:`Collector`)
@@ -90,14 +93,13 @@ class FeatureController(Controller):
         # now check if a definition for this class exists
         all_vdevices = self.get_abs_inner_vdevice_classes()
         # check the class based @for_vdevice and check the used vDevice classes here
-        if self.get_class_based_for_vdevice() is not None:
-            for cur_decorated_vdevice in self.get_class_based_for_vdevice().keys():
-                if cur_decorated_vdevice not in all_vdevices:
-                    raise VDeviceResolvingError(
-                        f"you assign a vDevice to the class based decorator `@for_vdevice()` of the feature class "
-                        f"`{self.related_cls.__name__}` which is no direct member of this feature - note that you have "
-                        f"to define the vDevice in your feature before using it in the decorator - if necessary "
-                        f"overwrite it")
+        for cur_decorated_vdevice in self.get_class_based_for_vdevice().keys():
+            if cur_decorated_vdevice not in all_vdevices:
+                raise VDeviceResolvingError(
+                    f"you assign a vDevice to the class based decorator `@for_vdevice()` of the feature class "
+                    f"`{self.related_cls.__name__}` which is no direct member of this feature - note that you have "
+                    f"to define the vDevice in your feature before using it in the decorator - if necessary "
+                    f"overwrite it")
         # check the method based @for_vdevice and check the used vDevice classes here
         if self.get_method_based_for_vdevice() is not None:
             for cur_method_name, cur_method_data in self.get_method_based_for_vdevice().items():
@@ -143,12 +145,18 @@ class FeatureController(Controller):
                                 VDevice
         :return: a dictionary that holds all available method variation that matches here
         """
+        all_vdevice_method_variations = self.get_method_based_for_vdevice()
+
+        if all_vdevice_method_variations is None:
+            raise ValueError("the current feature has no method variations")
+
+        if of_method_name not in all_vdevice_method_variations.keys():
+            raise ValueError(f"can not find the method `{of_method_name}` in method variation data dictionary")
+
         all_possible_method_variations = {}
-        for cur_impl_method, cur_method_impl_dict in self.get_method_based_for_vdevice()[of_method_name].items():
+        for cur_impl_method, cur_method_impl_dict in all_vdevice_method_variations[of_method_name].items():
             if for_vdevice in cur_method_impl_dict.keys():
-                cur_impl_method_cnns = []
-                for cur_cnn in cur_method_impl_dict[for_vdevice]:
-                    cur_impl_method_cnns += cur_cnn.get_singles()
+                cur_impl_method_cnns = cur_method_impl_dict[for_vdevice].get_singles()
                 for cur_single_impl_method_cnn in cur_impl_method_cnns:
                     if cur_single_impl_method_cnn.contained_in(with_connection, ignore_metadata=True):
                         # this variation is possible
@@ -158,29 +166,19 @@ class FeatureController(Controller):
                         # COMBINE IT if it is already available
                         else:
                             all_possible_method_variations[cur_impl_method] = Connection.based_on(
-                                all_possible_method_variations[cur_impl_method], cur_single_impl_method_cnn)
+                                OrConnectionRelation(all_possible_method_variations[cur_impl_method],
+                                                     cur_single_impl_method_cnn))
         return all_possible_method_variations
 
-
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
-    def get_class_based_for_vdevice(self) -> Union[Dict[Type[VDevice], List[Connection]], None]:
+    def get_class_based_for_vdevice(self) -> Dict[Type[VDevice], Connection]:
         """
-        This method returns the class based data for the `@for_vdevice` decorator or None, if there is no decorator
-        given
+        This method returns the class based data for the `@for_vdevice` decorator.
         """
-        result = {}
-
-        for cur_device, cnn_list in self._cls_for_vdevice.items():
-            result[cur_device] = []
-            for cur_cnn in cnn_list:
-                if isinstance(cur_cnn, type) and issubclass(cur_cnn, Connection):
-                    result[cur_device].append(cur_cnn())
-                else:
-                    result[cur_device].append(cur_cnn)
-        return result
+        return copy.copy(self._cls_for_vdevice)
 
-    def get_abs_class_based_for_vdevice(self) -> Dict[Type[VDevice], List[Union[Connection]]]:
+    def get_abs_class_based_for_vdevice(self) -> Dict[Type[VDevice], Connection]:
         """
         This method returns the absolute calculated class-based-for-vdevice data for this feature.
         """
@@ -188,8 +186,7 @@ class FeatureController(Controller):
             raise RuntimeError('can not access the absolute class based for-vdevices because they are not set yet')
         return self._abs_cls_for_vdevice
 
-    def set_class_based_for_vdevice(
-            self, data: Union[Dict[Type[VDevice], List[Union[Connection, Type[Connection]]]], None]):
+    def set_class_based_for_vdevice(self, data: Dict[Type[VDevice], Connection]):
         """
         This method allows to set the data of the class based `@for_vdevice` decorator.
         """
@@ -233,10 +230,9 @@ class FeatureController(Controller):
         all_vdevices = self.get_abs_inner_vdevice_classes()
 
         cls_based_for_vdevice = self.get_class_based_for_vdevice()
-        cls_based_for_vdevice = {} if cls_based_for_vdevice is None else cls_based_for_vdevice
         for cur_vdevice in all_vdevices:
             # determine the class based for_vdevice value only if there is no one defined for this vDevice
-            if cur_vdevice in cls_based_for_vdevice.keys() and len(cls_based_for_vdevice[cur_vdevice]) > 0:
+            if cur_vdevice in cls_based_for_vdevice.keys():
                 # there already exists a definition for this vDevice -> IGNORE
                 continue
 
@@ -263,13 +259,11 @@ class FeatureController(Controller):
             if vdevice_of_interest is not None and next_parent_feat is not None:
                 next_parent_feat_cls_based_for_vdevice = \
                     FeatureController.get_for(next_parent_feat).get_abs_class_based_for_vdevice()
-                next_parent_feat_cls_based_for_vdevice = {} if next_parent_feat_cls_based_for_vdevice is None else \
-                    next_parent_feat_cls_based_for_vdevice
                 if vdevice_of_interest in next_parent_feat_cls_based_for_vdevice.keys():
-                    for cur_cnn in next_parent_feat_cls_based_for_vdevice[vdevice_of_interest]:
-                        # clean metadata here because this is no connection between real devices
-                        cur_cnn.set_metadata_for_all_subitems(None)
-                        parent_values.append(cur_cnn)
+                    cnn = next_parent_feat_cls_based_for_vdevice[vdevice_of_interest]
+                    # clean metadata here because this is no connection between real devices
+                    cnn.set_metadata_for_all_subitems(None)
+                    parent_values.append(cnn)
 
             this_vdevice_intersection = parent_values
 
@@ -289,12 +283,12 @@ class FeatureController(Controller):
                         f'{", ".join([cur_cnn.get_tree_str() for cur_cnn in this_vdevice_intersection])})\n\n')
 
             # set the determined data into the class based `@for_vdevice` class property
-            cls_based_for_vdevice[cur_vdevice] = this_vdevice_intersection
+            cls_based_for_vdevice[cur_vdevice] = Connection.based_on(OrConnectionRelation(*this_vdevice_intersection))
 
         self._abs_cls_for_vdevice = cls_based_for_vdevice
 
     def get_method_based_for_vdevice(self) -> \
-            Union[Dict[str, Dict[Callable, Dict[Type[VDevice], List[Connection]]]], None]:
+            Union[Dict[str, Dict[Callable, Dict[Type[VDevice], Connection]]], None]:
         """
         This method returns the method based data for the `@for_vdevice` decorator or None, if there is no decorator
         given
@@ -302,16 +296,19 @@ class FeatureController(Controller):
         return self._for_vdevice
 
     def set_method_based_for_vdevice(
-            self, data: Union[Dict[str, Dict[Callable, Dict[Type[VDevice], List[Connection]]]], None]):
+            self, data: Union[Dict[str, Dict[Callable, Dict[Type[VDevice], Connection]]], None]):
         """
         This method allows to set the data for the method based `@for_vdevice` decorator.
         """
         self._for_vdevice = data
 
     def get_method_variation(
-            self, of_method_name: str, for_vdevice: Type[VDevice],
-            with_connection: Union[Connection, Tuple[Connection]], ignore_no_findings: bool = False) \
-            -> Union[Callable, None]:
+            self,
+            of_method_name: str,
+            for_vdevice: Type[VDevice],
+            with_connection: Connection,
+            ignore_no_findings: bool = False
+    ) -> Union[Callable, None]:
         """
         This method searches for the unique possible method variation and returns it. In its search, the method also
         includes the parent classes of the related feature element of this controller.
@@ -342,17 +339,6 @@ class FeatureController(Controller):
         :return: the method variation callable for the given data (or none, if the method does not exist in this object
                  or in a parent class of it)
         """
-
-        all_vdevice_method_variations = self.get_method_based_for_vdevice()
-
-        if isinstance(with_connection, tuple):
-            with_connection = Connection.based_on(with_connection)
-
-        if all_vdevice_method_variations is None:
-            raise ValueError("the current feature has no method variations")
-        if of_method_name not in all_vdevice_method_variations.keys():
-            raise ValueError(f"can not find the method `{of_method_name}` in method variation data dictionary")
-
         # first determine all possible method-variations
         all_possible_method_variations = self._determine_all_theoretically_unordered_method_variations(
             of_method_name=of_method_name, for_vdevice=for_vdevice, with_connection=with_connection)
@@ -378,31 +364,21 @@ class FeatureController(Controller):
         if len(all_possible_method_variations) == 1:
             return list(all_possible_method_variations.keys())[0]
 
-        # if there are more than one possible method variation, try to sort them hierarchical
-        # we have to determine the outer one
-        length_before = None
-        while length_before is None or length_before != len(all_possible_method_variations):
-            length_before = len(all_possible_method_variations)
-            for cur_meth, cur_cnn in all_possible_method_variations.items():
-                can_be_deleted = True
-                for _, cur_other_cnn in all_possible_method_variations.items():
-                    if cur_cnn == cur_other_cnn:
-                        continue
-                    if not cur_cnn.contained_in(cur_other_cnn):
-                        can_be_deleted = False
-                if can_be_deleted:
-                    del all_possible_method_variations[cur_meth]
-                    break
-            if len(all_possible_method_variations) == 1:
-                # done
-                break
-
-        if len(all_possible_method_variations) > 1:
+        # if there are more than one possible method variation, try to determine the outer one
+        remaining_possible_method_variations = list(
+            filter(
+                lambda meth: not max(all_possible_method_variations[meth].contained_in(cur_other_cnn)
+                                     for cur_other_cnn in all_possible_method_variations.values()
+                                     if cur_other_cnn != all_possible_method_variations[meth]),
+                all_possible_method_variations.keys())
+        )
+
+        if len(remaining_possible_method_variations) > 1:
             raise UnclearMethodVariationError(
                 f"found more than one possible method variation for method "
                 f"`{self.related_cls.__name__}.{of_method_name}` with vDevice `{for_vdevice.__name__}` "
                 f"and usable connection `{with_connection.get_tree_str()}´")
-        return list(all_possible_method_variations.keys())[0]
+        return remaining_possible_method_variations[0]
 
     def get_inner_vdevice_classes(self) -> List[Type[VDevice]]:
         """
@@ -592,26 +568,14 @@ class FeatureController(Controller):
                 FeatureController.get_for(
                     parent_vdevice_feature).get_abs_class_based_for_vdevice()[relevant_parent_class]
             # check if VDevice connection elements are all contained in the parent connection
-            for cur_element in cur_vdevice_cls_cnn:
-                if isinstance(cur_element, tuple):
-                    if not Connection.check_if_tuple_contained_in_connection(
-                            cur_element, Connection.based_on(*parent_vdevice_cnn)):
-                        raise VDeviceResolvingError(
-                            f"the VDevice `{cur_vdevice.__name__}` is a child of the VDevice "
-                            f"`{relevant_parent_class.__name__}`, which doesn't implements the connection of "
-                            f"the child - the connection tuple `("
-                            f"{', '.join([cur_tuple_item.get_tree_str() for cur_tuple_item in cur_element])})´"
-                            f" is not contained in the connection-tree of the parent VDevice")
-                else:
-                    if not cur_element.contained_in(
-                            Connection.based_on(*parent_vdevice_cnn), ignore_metadata=True):
-                        raise VDeviceResolvingError(
-                            f"the VDevice `{cur_vdevice.__name__}` is a child of the VDevice "
-                            f"`{relevant_parent_class.__name__}`, which doesn't implements the connection of "
-                            f"the child - the connection element `{cur_element.get_tree_str()})´ is not "
-                            f"contained in the connection-tree of the parent VDevice")
-
-        # check all features where we have found parent VDevices as inner-classes to check next inheritance levels
+            if not cur_vdevice_cls_cnn.contained_in(parent_vdevice_cnn, ignore_metadata=True):
+                raise VDeviceResolvingError(
+                    f"the VDevice `{cur_vdevice.__name__}` is a child of the VDevice "
+                    f"`{relevant_parent_class.__name__}`, which doesn't implements the connection of "
+                    f"the child - the connection element `{cur_vdevice_cls_cnn.get_tree_str()})´ is not "
+                    f"contained in the connection-tree of the parent VDevice")
+
+        # validate inheritance levels for all features with parent VDevices as inner-classes
         for cur_feature in to_checking_parent_features:
             FeatureController.get_for(cur_feature).validate_inherited_class_based_vdevice_cnn_subset()