baldertest 0.1.0b6__py3-none-any.whl → 0.1.0b8__py3-none-any.whl

_balder/_version.py

@@ -1,4 +1,16 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.1.0b6'
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.0b8'
 __version_tuple__ = version_tuple = (0, 1, 0)

_balder/balder_session.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
     from _balder.scenario import Scenario
     from _balder.connection import Connection
 
-
+# pylint: disable-next=too-many-instance-attributes
 class BalderSession:
     """
     This is the main balder executable object. It contains all information about the current session and executes the
@@ -60,6 +60,8 @@ class BalderSession:
         self.collect_only: Union[bool, None] = None
         #: specifies that the tests should only be collected and resolved but not executed
         self.resolve_only: Union[bool, None] = None
+        #: specifies that all discarded variations should be printed (with information why they were discarded)
+        self.show_discarded: Union[bool, None] = None
         #: contains a number of :class:`Setup` class strings that should only be considered for the execution
         self.only_with_setup: Union[List[str], None] = None
         #: contains a number of :class:`Scenario` class strings that should only be considered for the execution
@@ -246,6 +248,10 @@ class BalderSession:
             '--resolve-only', action='store_true',
             help="specifies that the tests are only collected and resolved but not executed")
 
+        self.cmd_arg_parser.add_argument(
+            '--show-discarded', action='store_true',
+            help="specifies that all discarded variations should be printed (with information why they were discarded)")
+
         self.cmd_arg_parser.add_argument(
             '--only-with-setup', nargs="*",
             help="defines a number of Setup classes which should only be considered for the execution")
@@ -262,14 +268,10 @@ class BalderSession:
 
         self.parsed_args = self.cmd_arg_parser.parse_args(self._alt_cmd_args)
 
-        if self.parsed_args.only_with_scenario is not None:
-            raise NotImplementedError("the parameter `--only-with-scenario` is not supported in this version of balder")
-        if self.parsed_args.only_with_setup is not None:
-            raise NotImplementedError("the parameter `--only-with-setup` is not supported in this version of balder")
-
         self.working_dir = self.parsed_args.working_dir
         self.collect_only = self.parsed_args.collect_only
         self.resolve_only = self.parsed_args.resolve_only
+        self.show_discarded = self.parsed_args.show_discarded
         self.only_with_setup = self.parsed_args.only_with_setup
         self.only_with_scenario = self.parsed_args.only_with_scenario
         self.force_covered_by_duplicates = self.parsed_args.force_covered_by_duplicates
@@ -278,7 +280,10 @@ class BalderSession:
         """
         This method collects all data.
         """
-        self.collector.collect(plugin_manager=self.plugin_manager)
+        self.collector.collect(
+            plugin_manager=self.plugin_manager,
+            scenario_filter_patterns=self.only_with_scenario,
+            setup_filter_patterns=self.only_with_setup)
 
     def solve(self):
         """
@@ -295,15 +300,10 @@ class BalderSession:
         .. note::
             Note that the method creates an :class:`ExecutorTree`, that hasn't to be completely resolved yet.
         """
-        self.executor_tree = self.solver.get_executor_tree(plugin_manager=self.plugin_manager)
+        self.executor_tree = self.solver.get_executor_tree(plugin_manager=self.plugin_manager,
+                                                           add_discarded=self.show_discarded)
         self.plugin_manager.execute_filter_executor_tree(executor_tree=self.executor_tree)
 
-    def execute_executor_tree(self):
-        """
-        This method executes the :class:`ExecutorTree`.
-        """
-        self.executor_tree.execute()
-
     def run(self):
         """
         This method executes the whole session
@@ -326,11 +326,14 @@ class BalderSession:
         if not self.collect_only:
             self.solve()
             self.create_executor_tree()
-            print(f"  resolve them to {len(self.executor_tree.get_all_variation_executors())} mapping candidates")
+            count_valid = len(self.executor_tree.get_all_variation_executors())
+            count_discarded = len(self.executor_tree.get_all_variation_executors(return_discarded=True)) - count_valid
+            addon_text = f" ({count_discarded} discarded)" if self.show_discarded else ""
+            print(f"  resolve them to {count_valid} valid variations{addon_text}")
             print("")
             if not self.resolve_only:
-                self.execute_executor_tree()
+                self.executor_tree.execute(show_discarded=self.show_discarded)
             else:
-                self.executor_tree.print_tree()
+                self.executor_tree.print_tree(show_discarded=self.show_discarded)
 
         self.plugin_manager.execute_session_finished(self.executor_tree)

_balder/collector.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
-from typing import List, Type, Union, Dict, Callable, Tuple, TYPE_CHECKING
+from typing import List, Type, Union, Dict, Callable, Tuple, TYPE_CHECKING, Any
 
 import os
 import sys
 import types
 import logging
+import fnmatch
 import inspect
 import pathlib
 import functools
@@ -677,27 +678,58 @@ class Collector:
         for cur_setup in self.all_setups:
             SetupController.get_for(cur_setup).validate_feature_possibility()
 
-    def collect(self, plugin_manager: PluginManager):
+    def _filter_paths_after_allowed_paths(self, paths: List[pathlib.Path], filter_patterns: List[str]) -> List[pathlib.Path]:
+        """
+        This method filters the given list of filepaths for the given filter_patterns. It returns a list with all
+        remaining paths that are mathing the filter statements in `filter_paths`.
+
+        Patterns are the same like for `fnmatch <https://docs.python.org/3/library/fnmatch.html#module-fnmatch>`_.
+
+        :param paths: a list of all filepaths that should be filtered
+        :param filter_patterns: a list of relative filter patterns that should be applied on the files of the classes
+        :return: returns all classes of items that match any of the given patterns.
+        """
+        remaining = []
+
+        for cur_pattern in filter_patterns:
+            remaining += [cur_abs_path for cur_abs_path in paths
+                          if fnmatch.fnmatch(str(cur_abs_path.relative_to(self.working_dir)), cur_pattern)]
+        return list(set(remaining))
+
+
+    def collect(self, plugin_manager: PluginManager, scenario_filter_patterns: Union[List[str], None],
+                setup_filter_patterns: Union[List[str], None]):
         """
         This method manages the entire collection process.
 
         :param plugin_manager: contains the reference to the used plugin manager
+        :param scenario_filter_patterns: a list with filter patterns for scenarios
+        :param setup_filter_patterns: a list with filter patterns for setups
         """
         # load all py files
         self.load_balderglob_py_file()
         self._all_py_files = self.get_all_py_files()
         self._all_py_files = plugin_manager.execute_modify_collected_pyfiles(self._all_py_files)
 
+        if scenario_filter_patterns:
+            all_scenario_filepaths = self._filter_paths_after_allowed_paths(
+                paths=self._all_py_files, filter_patterns=scenario_filter_patterns)
+        else:
+            all_scenario_filepaths = self._all_py_files
+        if setup_filter_patterns:
+            all_setup_filepaths = self._filter_paths_after_allowed_paths(
+                paths=self._all_py_files, filter_patterns=setup_filter_patterns)
+        else:
+            all_setup_filepaths = self._all_py_files
+
         # collect all `Connection` classes (has to be first, because scenarios/setups can use them)
         self.load_all_connection_classes(py_file_paths=self._all_py_files)
         self._all_connections = self.get_all_connection_classes()
 
         # collect all `Scenario` classes
-        self._all_scenarios = self.get_all_scenario_classes(
-            py_file_paths=self._all_py_files, filter_abstracts=True)
+        self._all_scenarios = self.get_all_scenario_classes(py_file_paths=all_scenario_filepaths, filter_abstracts=True)
         # collect all `Setup` classes
-        self._all_setups = self.get_all_setup_classes(
-            py_file_paths=self._all_py_files, filter_abstracts=True)
+        self._all_setups = self.get_all_setup_classes(py_file_paths=all_setup_filepaths, filter_abstracts=True)
 
         self._all_scenarios, self._all_setups = plugin_manager.execute_collected_classes(
             scenarios=self._all_scenarios, setups=self._all_setups)

_balder/connection.py

@@ -88,6 +88,17 @@ class Connection:
             all_hashes += hash(cur_child)
         return hash(all_hashes)
 
+    def clone_without_based_on_elements(self) -> Connection:
+        """
+        This method returns a copied version of this element, while all `_based_on_connections` are removed (the copied
+        element has an empty list here).
+
+        :return: a python copied object of this item
+        """
+        self_copy = copy.copy(self)
+        self_copy._based_on_connections = []  # pylint: disable=protected-access
+        return self_copy
+
     def clone(self) -> Connection:
         """
         This method returns an exact clone of this connection. For this clone every inner connection object will be
@@ -95,18 +106,15 @@ class Connection:
         same for this object and the clone). The method will make a normal copy for every connection object in the
         `_based_on_elements` list.
         """
-        self_copy = copy.copy(self)
-        self_copy._based_on_connections = []
+        self_copy = self.clone_without_based_on_elements()
 
         for cur_based_on in self._based_on_connections:
             if isinstance(cur_based_on, tuple):
-                cloned_tuple = ()
-                for cur_tuple_element in cur_based_on:
-                    cloned_tuple = cloned_tuple + (cur_tuple_element.clone(), )
-                self_copy._based_on_connections.append(cloned_tuple)
+                cloned_tuple = tuple([cur_tuple_element.clone() for cur_tuple_element in cur_based_on])
+                self_copy.append_to_based_on(cloned_tuple)
             elif isinstance(cur_based_on, Connection):
                 cloned_cur_based_on = cur_based_on.clone()
-                self_copy._based_on_connections.append(cloned_cur_based_on)
+                self_copy.append_to_based_on(cloned_cur_based_on)
             else:
                 raise TypeError('based on element is not from valid type')
         return self_copy
@@ -132,22 +140,21 @@ class Connection:
             for cur_tuple in Connection.__cut_tuple_from_only_parent_to_child(elem.based_on_elements[0]):
                 # for this we do not have to use `clone`, because we copy the base object with `copy.copy` and
                 # completely replace the `_based_on_connections` by our own
-                copied_conn = copy.copy(elem)
-                copied_conn._based_on_connections = [cur_tuple]
+                copied_conn = elem.clone_without_based_on_elements()
+                copied_conn.append_to_based_on(cur_tuple)
                 all_pieces.append(copied_conn)
             return all_pieces
         # if this element is the last element with a parent -> copy it and remove the parent, return it
         if len(elem.based_on_elements[0].based_on_elements) == 0:
-            new_elem = copy.copy(elem)
-            new_elem._based_on_connections = []
+            new_elem = elem.clone_without_based_on_elements()
             all_pieces.append(new_elem)
             return all_pieces
         # otherwise, the current item has grandparents, so call the method recursively for parents and add a copy of
         # this object as child
         all_possible_parents = Connection.__cut_conn_from_only_parent_to_child(elem.based_on_elements[0])
         for cur_parent in all_possible_parents:
-            copied_conn = copy.copy(elem)
-            copied_conn._based_on_connections = [cur_parent]
+            copied_conn = elem.clone_without_based_on_elements()
+            copied_conn.append_to_based_on(cur_parent)
             all_pieces.append(copied_conn)
         return all_pieces
 
@@ -165,15 +172,12 @@ class Connection:
             Note that this method also returns every possible ordering
         """
 
-        tuple_with_all_possibilities = ()
-        for cur_tuple_item in elem:
-            tuple_with_all_possibilities += (Connection.__cut_conn_from_only_parent_to_child(cur_tuple_item), )
+        tuple_with_all_possibilities = (
+            tuple([Connection.__cut_conn_from_only_parent_to_child(cur_tuple_item) for cur_tuple_item in elem]))
 
         cloned_tuple_list = []
         for cur_tuple in list(itertools.product(*tuple_with_all_possibilities)):
-            cloned_tuple: Tuple[Connection] = ()
-            for cur_tuple_item in cur_tuple:
-                cloned_tuple += (cur_tuple_item.clone(), )
+            cloned_tuple = tuple([cur_tuple_item.clone() for cur_tuple_item in cur_tuple])
             cloned_tuple_list.append(cloned_tuple)
         return cloned_tuple_list
 
@@ -215,11 +219,9 @@ class Connection:
                 while len(cur_sub_other_single) > 0:
                     if isinstance(cur_sub_other_single[0], tuple):
                         # found a tuple -> check if length does match
-                        if len(cur_sub_other_single[0]) >= len(cur_tuple_single):
-                            # length does match
-                            if tuple_is_contained_in_other(
-                                    cur_tuple_single, contained_in_tuple=cur_sub_other_single[0]):
-                                return True
+                        if len(cur_sub_other_single[0]) >= len(cur_tuple_single) and tuple_is_contained_in_other(
+                                cur_tuple_single, contained_in_tuple=cur_sub_other_single[0]):
+                            return True
                         # otherwise, this complete element is not possible - skip this single!
                         break
                     cur_sub_other_single = cur_sub_other_single[0].based_on_elements
@@ -371,6 +373,75 @@ class Connection:
         this_instance.append_to_based_on(*new_items)
         return this_instance
 
+    @classmethod
+    def check_equal_connections_are_in(
+            cls, cnns_from: List[Connection], are_in_cnns_from: List[Connection], ignore_metadata: bool=False) -> bool:
+        """
+        This method validates that the elements from the first list are contained (are equal) with one of the elements
+        in the second list.
+
+        .. note::
+            This method only checks that every single connections from the first element is contained in the second too.
+            It does not check the other direction. If you want to validate this, you need to call this method with both
+            possibilities.
+
+        :param cnns_from: the first list of connections
+        :param are_in_cnns_from: the second list of connection
+        :param ignore_metadata: True, if the metadata of the single connections should be ignored
+        :return: True in case that every connection of the first list is equal with one in the second list, otherwise
+                 False
+        """
+        for cur_cnn in cnns_from:
+            found_equal = False
+            for cur_other_cnn in are_in_cnns_from:
+                if cur_cnn.equal_with(cur_other_cnn, ignore_metadata=ignore_metadata):
+                    found_equal = True
+                    break
+            if not found_equal:
+                return False
+        return True
+
+    @classmethod
+    def check_equal_connection_tuples_are_in(
+            cls, tuples_from: List[Tuple[Connection]], are_in_tuples_from: List[Tuple[Connection]],
+            ignore_metadata: bool=False) -> bool:
+        """
+        This method validates that the connection tuples from the first list are contained (are equal) within the tuple
+        elements of the second list.
+
+        .. note::
+            This method only checks that every single tuple from the first element is contained in the second list.
+            It does not check the other direction. If you want to validate this, you need to call this method with both
+            possibilities.
+
+        :param tuples_from: the first list of connection-tuples
+        :param are_in_tuples_from: the second list of connection-tuples
+        :param ignore_metadata: True, if the metadata of the single connections should be ignored
+        :return: True in case that every tuple connections of the first list is equal with one tuple in the second,
+                 otherwise False
+        """
+        for cur_search_tuple in tuples_from:
+            found_match_for_cur_search_tuple = False
+            # go through each unmatched other tuple
+            for cur_other_tuple in are_in_tuples_from:
+                cur_search_tuple_is_completely_in_other_tuple = True
+                for cur_search_tuple_elem in cur_search_tuple:
+                    fount_it = False
+                    for cur_other_tuple_elem in cur_other_tuple:
+                        if cur_search_tuple_elem.equal_with(cur_other_tuple_elem, ignore_metadata=ignore_metadata):
+                            fount_it = True
+                            break
+                    if not fount_it:
+                        cur_search_tuple_is_completely_in_other_tuple = False
+                        break
+                if cur_search_tuple_is_completely_in_other_tuple:
+                    # here we have no match
+                    found_match_for_cur_search_tuple = True
+                    break
+            if not found_match_for_cur_search_tuple:
+                return False
+        return True
+
     # ---------------------------------- PROPERTIES --------------------------------------------------------------------
 
     @property
@@ -484,7 +555,7 @@ class Connection:
 
         return False
 
-    def _get_intersection_with_other_single(self, other_conn: Union[Connection, Tuple[Connection]]) \
+    def get_intersection_with_other_single(self, other_conn: Union[Connection, Tuple[Connection]]) \
             -> List[Connection, Tuple[Connection]]:
         """
         A helper method that returns an intersection between the two connections (self and the given one).
@@ -519,27 +590,23 @@ class Connection:
 
         intersection = []
 
+        def determine_for(pieces: List[Union[Connection, Tuple[Connection]]], in_other_cnn: Connection):
+            for cur_piece in pieces:
+                if isinstance(cur_piece, Connection):
+                    if cur_piece.contained_in(in_other_cnn, ignore_metadata=True):
+                        intersection.append(cur_piece)
+                else:
+                    # isinstance of tuple
+                    if Connection.check_if_tuple_contained_in_connection(cur_piece, in_other_cnn):
+                        intersection.append(cur_piece)
+
         #: check if some sub elements of self connection are contained in `other_conn`
         self_pieces = self.cut_into_all_possible_subtrees()
-        for cur_piece in self_pieces:
-            if isinstance(cur_piece, Connection):
-                if cur_piece.contained_in(other_conn, ignore_metadata=True):
-                    intersection.append(cur_piece)
-            else:
-                # isinstance of tuple
-                if Connection.check_if_tuple_contained_in_connection(cur_piece, other_conn):
-                    intersection.append(cur_piece)
+        determine_for(pieces=self_pieces, in_other_cnn=other_conn)
 
         #: check if some sub elements of `other_conn` are contained in self connection
         other_pieces = other_conn.cut_into_all_possible_subtrees()
-        for cur_piece in other_pieces:
-            if isinstance(cur_piece, Connection):
-                if cur_piece.contained_in(self, ignore_metadata=True):
-                    intersection.append(cur_piece)
-            else:
-                # isinstance of tuple
-                if Connection.check_if_tuple_contained_in_connection(cur_piece, self):
-                    intersection.append(cur_piece)
+        determine_for(pieces=other_pieces, in_other_cnn=self)
 
         #: filter all duplicated (and contained in each other) connections
         intersection_without_duplicates = []
@@ -779,19 +846,19 @@ class Connection:
             method returns this child connection directly without any :class:`Connection` container otherwise the
             :class:`Connection` container class with all resolved child classes will be returned.
         """
-        copied_base = copy.copy(self)
-        if not copied_base.is_resolved():
-            copied_base._based_on_connections = []
+        if self.is_resolved():
+            copied_base = self.clone()
+        else:
+            copied_base = self.clone_without_based_on_elements()
+
             if self.__class__ == Connection:
                 # the base object is a container Connection - iterate over the items and determine the values for them
                 for cur_item in self.based_on_elements.copy():
                     if isinstance(cur_item, tuple):
-                        new_tuple = ()
-                        for cur_tuple_item in cur_item:
-                            new_tuple += (cur_tuple_item.get_resolved(), )
-                        copied_base._based_on_connections.append(new_tuple)
+                        new_tuple = tuple([cur_tuple_item.get_resolved() for cur_tuple_item in cur_item])
+                        copied_base.append_to_based_on(new_tuple)
                     else:
-                        copied_base._based_on_connections.append(cur_item.get_resolved())
+                        copied_base.append_to_based_on(cur_item.get_resolved())
             else:
                 for next_higher_parent in self.based_on_elements:
                     if isinstance(next_higher_parent, tuple):
@@ -811,21 +878,20 @@ class Connection:
                         # resolve the opportunities and create multiple possible tuples where all elements are direct
                         # parents
                         for cur_possibility in itertools.product(*direct_ancestors_tuple):
-                            new_child_tuple = ()
-                            for cur_tuple_element in cur_possibility:
-                                new_child_tuple += (cur_tuple_element.get_resolved(), )
-                            copied_base._based_on_connections.append(new_child_tuple)
+                            new_child_tuple = (
+                                tuple([cur_tuple_element.get_resolved() for cur_tuple_element in cur_possibility]))
+                            copied_base.append_to_based_on(new_child_tuple)
                     else:
                         if next_higher_parent.__class__ in self.__class__.get_parents():
                             # is already a direct parent
-                            copied_base._based_on_connections.append(next_higher_parent.get_resolved())
+                            copied_base.append_to_based_on(next_higher_parent.get_resolved())
                         else:
                             # only add the first level of direct parents - deeper will be added by recursively call of
                             # `get_resolved`
                             for cur_self_direct_parent in self.__class__.get_parents():
                                 if next_higher_parent.__class__.is_parent_of(cur_self_direct_parent):
                                     new_child = cur_self_direct_parent.based_on(next_higher_parent)
-                                    copied_base._based_on_connections.append(new_child.get_resolved())
+                                    copied_base.append_to_based_on(new_child.get_resolved())
         # if it is a connection container, where only one element exists that is no tuple -> return this directly
         # instead of the container
         if copied_base.__class__ == Connection and len(copied_base.based_on_elements) == 1 and not \
@@ -865,8 +931,8 @@ class Connection:
                     return [resolved_obj]
                 for cur_child in resolved_obj.based_on_elements:
                     for cur_single_child in cur_child.get_singles():
-                        copied_base = copy.copy(resolved_obj)
-                        copied_base._based_on_connections = [cur_single_child]
+                        copied_base = resolved_obj.clone_without_based_on_elements()
+                        copied_base.append_to_based_on(cur_single_child)
                         all_singles.append(copied_base)
         # convert all tuple objects in a connection object and set metadata of self object
         cleaned_singles = []
@@ -979,40 +1045,6 @@ class Connection:
         resolved_self = self.get_resolved()
         resolved_other = other_conn.get_resolved()
 
-        def check_elems_if(elems_from, are_in_elems_from):
-            for cur_elem in elems_from:
-                found_equal = False
-                for cur_other_elem in are_in_elems_from:
-                    if cur_elem.equal_with(cur_other_elem, ignore_metadata=ignore_metadata):
-                        found_equal = True
-                        break
-                if not found_equal:
-                    return False
-            return True
-
-        def check_tuples_if(tuples_from, are_in_tuples_from):
-            for cur_search_tuple in tuples_from:
-                found_match_for_cur_search_tuple = False
-                # go through each unmatched other tuple
-                for cur_other_tuple in are_in_tuples_from:
-                    cur_search_tuple_is_completely_in_other_tuple = True
-                    for cur_search_tuple_elem in cur_search_tuple:
-                        fount_it = False
-                        for cur_other_tuple_elem in cur_other_tuple:
-                            if cur_search_tuple_elem.equal_with(cur_other_tuple_elem, ignore_metadata=ignore_metadata):
-                                fount_it = True
-                                break
-                        if not fount_it:
-                            cur_search_tuple_is_completely_in_other_tuple = False
-                            break
-                    if cur_search_tuple_is_completely_in_other_tuple:
-                        # here we have no match
-                        found_match_for_cur_search_tuple = True
-                        break
-                if not found_match_for_cur_search_tuple:
-                    return False
-            return True
-
         self_based_on_elems = [
             cur_elem for cur_elem in resolved_self.based_on_elements if isinstance(cur_elem, Connection)]
         self_based_on_tuples = [
@@ -1023,13 +1055,20 @@ class Connection:
             cur_elem for cur_elem in resolved_other.based_on_elements if isinstance(cur_elem, tuple)]
 
         # check single connection elements (if they match all in both directions)
-        if not check_elems_if(elems_from=self_based_on_elems, are_in_elems_from=other_based_on_elems) or \
-                not check_elems_if(elems_from=other_based_on_elems, are_in_elems_from=self_based_on_elems):
+        if (not self.__class__.check_equal_connections_are_in(
+                cnns_from=self_based_on_elems, are_in_cnns_from=other_based_on_elems, ignore_metadata=ignore_metadata)
+                or not self.__class__.check_equal_connections_are_in(
+                    cnns_from=other_based_on_elems, are_in_cnns_from=self_based_on_elems,
+                    ignore_metadata=ignore_metadata)):
             return False
 
         # check tuple connection elements (if they match all in both directions)
-        if not check_tuples_if(tuples_from=self_based_on_tuples, are_in_tuples_from=other_based_on_tuples) or \
-                not check_tuples_if(tuples_from=other_based_on_tuples, are_in_tuples_from=self_based_on_tuples):
+        if (not self.__class__.check_equal_connection_tuples_are_in(
+                tuples_from=self_based_on_tuples, are_in_tuples_from=other_based_on_tuples,
+                ignore_metadata=ignore_metadata)
+                or not self.__class__.check_equal_connection_tuples_are_in(
+                    tuples_from=other_based_on_tuples, are_in_tuples_from=self_based_on_tuples,
+                    ignore_metadata=ignore_metadata)):
             return False
 
         return True
@@ -1208,7 +1247,7 @@ class Connection:
         # determine intersections between all of these single components
         for cur_self_conn in self_conn_singles:
             for cur_other_conn in other_conn_singles:
-                for cur_intersection in cur_self_conn._get_intersection_with_other_single(cur_other_conn):
+                for cur_intersection in cur_self_conn.get_intersection_with_other_single(cur_other_conn):
                     if isinstance(cur_intersection, tuple):
                         cur_intersection = Connection.based_on(cur_intersection)
                     if cur_intersection not in intersections:
@@ -1236,7 +1275,8 @@ class Connection:
 
         return intersection_filtered[0].clone()
 
-    def append_to_based_on(self, *args: Union[Tuple[Union[Type[Connection], Connection]]]) -> None:
+    def append_to_based_on(
+            self, *args: Union[Connection, Type[Connection], Tuple[Union[Type[Connection], Connection]]]) -> None:
         """
         with this method you can extend the internal based_on list with the transferred elements. Any number of
         :meth:`Connection` objects or tuples with :meth:`Connection` objects can be given to this method

_balder/console/balder.py

@@ -15,6 +15,7 @@ def console_balder(cmd_args: Optional[List[str]] = None, working_dir: Union[str,
     _console_balder_debug(cmd_args=cmd_args, working_dir=working_dir)
 
 
+# pylint: disable-next=too-many-arguments
 def _console_balder_debug(cmd_args: Optional[List[str]] = None, working_dir: Union[str, pathlib.Path, None] = None,
                           cb_session_created: Optional[Callable] = None, cb_run_finished: Optional[Callable] = None,
                           cb_balder_exc: Optional[Callable] = None, cb_unexpected_exc: Optional[Callable] = None):

_balder/controllers/base_device_controller.py

@@ -58,9 +58,8 @@ class BaseDeviceController(Controller, ABC):
         This method returns the original instanced feature objects of the related device
         """
         if self._original_instanced_features is None:
-            # todo we should use a balder exception here!!
-            raise EnvironmentError('can not access the original instantiated features before they were set with '
-                                   '`save_all_original_instanced_features`')
+            raise RuntimeError('can not access the original instantiated features before they were set with '
+                               '`save_all_original_instanced_features`')
         return self._original_instanced_features
 
     def save_all_original_instanced_features(self):

_balder/controllers/feature_controller.py

@@ -117,13 +117,14 @@ class FeatureController(Controller):
         if self.get_method_based_for_vdevice() is not None:
             for _, method_dict in self.get_method_based_for_vdevice().items():
                 for _, vdevice_dict in method_dict.items():
-                    if for_vdevice in vdevice_dict.keys():
-                        for cur_cnn in vdevice_dict[for_vdevice]:
-                            if isinstance(cur_cnn, type):
-                                cur_cnn = cur_cnn()
-                            # clean metadata here because this is no connection between real devices
-                            cur_cnn.set_metadata_for_all_subitems(None)
-                            intersection.append(cur_cnn)
+                    if for_vdevice not in vdevice_dict.keys():
+                        continue
+                    for cur_cnn in vdevice_dict[for_vdevice]:
+                        if isinstance(cur_cnn, type):
+                            cur_cnn = cur_cnn()
+                        # clean metadata here because this is no connection between real devices
+                        cur_cnn.set_metadata_for_all_subitems(None)
+                        intersection.append(cur_cnn)
         if len(intersection) == 0:
             return [Connection()]
         return intersection
@@ -151,8 +152,7 @@ class FeatureController(Controller):
         This method returns the absolute calculated class-based-for-vdevice data for this feature.
         """
         if self._abs_cls_for_vdevice is None:
-            # todo we should use a balder exception here!!
-            raise EnvironmentError('can not access the absolute class based for-vdevices because they are not set')
+            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(
@@ -718,9 +718,8 @@ class FeatureController(Controller):
         This method returns the :class:`VDevice` definitions that are the original definitions for this feature.
         """
         if self._original_vdevice_definitions is None:
-            # todo we should use a balder exception here!!
-            raise EnvironmentError('can not access the original VDevice definitions before they were set with '
-                                   '`save_all_current_vdevice_references_as_originals`')
+            raise RuntimeError('can not access the original VDevice definitions before they were set with '
+                               '`save_all_current_vdevice_references_as_originals`')
         return self._original_vdevice_definitions
 
     def save_all_current_vdevice_references_as_originals(self):

_balder/exceptions.py

@@ -158,7 +158,7 @@ class IllegalVDeviceMappingError(BalderException):
     """
 
 
-class NotApplicableVariationError(BalderException):
+class NotApplicableVariationException(BalderException):
     """
     is thrown internally after the current variation is not applicable
     """