baldertest 0.1.0b10__tar.gz → 0.1.0b11__tar.gz

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/.pylintrc

@@ -274,7 +274,7 @@ exclude-too-few-public-methods=
 ignored-parents=
 
 # Maximum number of arguments for function / method.
-max-args=5
+max-args=6
 
 # Maximum number of attributes for a class (see R0902).
 max-attributes=15

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/.readthedocs.yml

@@ -6,6 +6,8 @@ build:
     python: "3.9"
 
 sphinx:
+  # Path to your Sphinx configuration file.
+  configuration: doc/source/conf.py
   fail_on_warning: true
 
 python:

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

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

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/doc/source/basics/connections.rst

@@ -83,34 +83,11 @@ It is also possible that a connection requires multiple other connections (**AND
 :class:`.DnsConnection` requires a :class:`UdpConnection` **AND** a :class:`TcpConnection`, because DNS uses UDP per
 default, but it uses TCP for requests that sends data that is to much for UDP.
 
-So we can define an AND connection simply by using tuples:
+So we can define an AND connection simply with:
 
 .. code-block::
 
-    conn = DnsConnection.based_on((UdpConnection, TcpConnection))
-
-Limits of connection-relations
-------------------------------
-
-You can define **AND**/**OR** definitions in almost any possible variation, but there is one limit.
-It is not allowed to define **AND** connections inside other **AND** connections, so for example:
-
-.. code-block:: python
-
-    # ALLOWED
-    conn = SpecialConnection.based_on((AConnection, BConnection), CConnection)
-    # NOT ALLOWED
-    conn = SpecialConnection.based_on((AConnection, BConnection, (CConnection, DConnection)))
-
-The last definition is not allowed because we use an inner **AND** connection there. We can write the same logic more
-easier by refactoring the both **AND** relations:
-
-.. code-block:: python
-
-    # same like the NOT ALLOWED tree from above - BUT NOW IT IS ALLOWED
-    conn = SpecialConnection.based_on((AConnection, BConnection, CConnection, DConnection)))
-
-This limitation makes it easier to read the logic.
+    conn = DnsConnection.based_on(UdpConnection & TcpConnection)
 
 Using the base connection object
 ================================
@@ -139,7 +116,7 @@ connection:
 
 .. code-block:: python
 
-    conn = Connection.based_on(AConnection, BConnection)
+    conn = Connection.based_on(AConnection | BConnection)
 
 **A container connection always has based-on elements**.
 

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/doc/source/basics/features.rst

@@ -325,7 +325,7 @@ Basically our scenario level implementation looks like:
     from balder.connections import TcpConnection
     from .connections import SerialConnection
 
-    @balder.for_vdevice(with_vdevice='OtherVDevice', [TcpConnection, SerialConnection])
+    @balder.for_vdevice('OtherVDevice', with_connections=TcpConnection | SerialConnection)
     class SendMessengerFeature(balder.Feature):
 
         class OtherVDevice(balder.VDevice):
@@ -394,12 +394,12 @@ use the **Method-Based-Binding** decorator:
 
     class SetupSendMessengerFeature(MessengerFeature):
 
-        @balder.for_vdevice(MessengerFeature.OtherVDevice, with_connection=SerialConnection)
+        @balder.for_vdevice(MessengerFeature.OtherVDevice, with_connections=SerialConnection)
         def send(msg) -> None:
             serial = MySerial(com=..)
             ...
 
-        @balder.for_vdevice(MessengerFeature.OtherVDevice, with_connection=TcpConnection)
+        @balder.for_vdevice(MessengerFeature.OtherVDevice, with_connections=TcpConnection)
         def send(msg) -> None:
             sock = socket.socket(...)
             ...
@@ -419,7 +419,7 @@ So take a look at the following :class:`Setup`, that matches our :class:`Scenari
 
     class MySetup(balder.Setup):
 
-        @balder.connect(SlaveDevice, over_connection=balder.Connection.based_on(SerialConnection, TcpConnection))
+        @balder.connect(SlaveDevice, over_connection=SerialConnection | TcpConnection)
         class MainDevice(balder.Device):
             msg = SetupSendMessengerFeature()
 
@@ -429,7 +429,7 @@ So take a look at the following :class:`Setup`, that matches our :class:`Scenari
 This example connects the two relevant devices over a :class:`TcpConnection` with each other, because the scenario
 defines, that the devices should be connected over an TcpConnection. If the test
 now uses on of our methods ``MyMessengerFeature.send(..)``, the variation with the decorator
-``@balder.for_vdevice(..., over_connection=[TcpConnection])`` will be used.
+``@balder.for_vdevice(..., over_connection=TcpConnection)`` will be used.
 
 If one would exchange the connection with the ``SerialConnection``, Balder would select the method variation with the
 decorator ``@balder.for_vdevice(MessengerFeature.OtherVDevice, with_connection=SerialConnection)``.

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/doc/source/basics/scenarios.rst

@@ -79,9 +79,9 @@ You can also define some by your own.
 In addition to define single connections, you can also select a part of the global connection tree or combine some
 connections with an OR or an AND relationship. So for example you could connect our devices and allow an Ethernet as
 well as a Serial connection, by defining
-``@balder.connect(SendDevice, over_connection=Connection.based_on(MyEthernet, MySerial))``. Of course you could also
-define, that you need both, the Serial and the Ethernet connection. This can be done by using tuples:
-``@balder.connect(SendDevice, over_connection=Connection.based_on((MyEthernet, MySerial)))``
+``@balder.connect(SendDevice, over_connection=MyEthernet | MySerial)``. Of course you could also
+define, that you need both, the Serial and the Ethernet connection. This can be done with:
+``@balder.connect(SendDevice, over_connection=MyEthernet & MySerial``
 
 In our example we only define that we want a universal :class:`Connection` between our devices ``SendDevice`` and
 ``RecvDevice``. With this the connection type doesn't matter and every connection works here.

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/doc/source/basics/vdevices.rst

@@ -316,7 +316,7 @@ Let's go back to an easy scenario which only has one single vDevice:
         class Receiver(balder.Device):
             recv = RecvFeature()
 
-        @balder.connect(with_device=Receiver, over_connection=balder.Connection.based_on(SmsConnection, EMailConnection))
+        @balder.connect(with_device=Receiver, over_connection=SmsConnection | EMailConnection)
         class Sender(balder.Device):
             send = SendFeature(receiver=ScenarioSendMessage.Receiver)
 
@@ -405,11 +405,11 @@ all of that with our two features ``SendFeature`` and ``RecvFeature``:
             send_to_recv1 = SendFeature(receiver='Receiver1')
             send_to_recv2 = SendFeature(receiver='Receiver2')
 
-        @balder.connect(with_device=Sender, over_connection=balder.Connection.based_on(SmsConnection, EMailConnection))
+        @balder.connect(with_device=Sender, over_connection=SmsConnection | EMailConnection)
         class Receiver1(balder.Device):
             recv = RecvFeature()
 
-        @balder.connect(with_device=Sender, over_connection=balder.Connection.based_on(SmsConnection, EMailConnection))
+        @balder.connect(with_device=Sender, over_connection=SmsConnection | EMailConnection)
         class Receiver2(balder.Device):
             recv = RecvFeature()
 

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/requirements.txt

@@ -6,7 +6,7 @@ docutils==0.17.1
 idna==3.7
 imagesize==1.2.0
 furo==2022.1.2
-Jinja2==3.1.4
+Jinja2==3.1.5
 MarkupSafe==2.0.1
 packaging==21.0
 Pygments==2.15.0

{baldertest-0.1.0b10 → baldertest-0.1.0b11}/setup.cfg

@@ -34,9 +34,10 @@ console_scripts =
 [options]
 packages = 
 	_balder
+	_balder.cnnrelations
 	_balder.console
-	_balder.executor
 	_balder.controllers
+	_balder.executor
 	_balder.objects
 	_balder.objects.devices
 	_balder.objects.connections

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

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

baldertest-0.1.0b11/src/_balder/cnnrelations/__init__.py

@@ -0,0 +1,7 @@
+from .and_connection_relation import AndConnectionRelation
+from .or_connection_relation import OrConnectionRelation
+
+__all__ = [
+    'AndConnectionRelation',
+    'OrConnectionRelation'
+]

baldertest-0.1.0b11/src/_balder/cnnrelations/and_connection_relation.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import itertools
+
+from .base_connection_relation import BaseConnectionRelation, BaseConnectionRelationT
+
+if TYPE_CHECKING:
+    from ..connection import List, Union, Connection
+    from .or_connection_relation import OrConnectionRelation
+
+
+class AndConnectionRelation(BaseConnectionRelation):
+    """
+    describes an AND relation between connections
+    """
+
+    def get_tree_str(self) -> str:
+        based_on_strings = [cur_elem.get_tree_str() for cur_elem in self._connections]
+        return f"({' | '.join(based_on_strings)})"
+
+    def get_simplified_relation(self) -> OrConnectionRelation:
+        from ..connection import Connection  # pylint: disable=import-outside-toplevel
+        from .or_connection_relation import OrConnectionRelation  # pylint: disable=import-outside-toplevel
+
+        # create template with all elements that are definitely contained in every new AND relation (only
+        # ``Connection`` objects here)
+        and_template = AndConnectionRelation()
+        # add all OR relations that needs to be further resolved to that list
+        self_simplified_or_relations = []
+
+        # first: go through all inner elements and convert all relations in simplified relations
+        for cur_elem in self.connections:
+            if isinstance(cur_elem, Connection):
+                # that is fine - add it to the template
+                and_template.append(cur_elem)
+            elif isinstance(cur_elem, (AndConnectionRelation, OrConnectionRelation)):
+                # simplify this AND/OR relation and add the items of it
+                # (the simplified version is always an OR relation!)
+                self_simplified_or_relations.append(cur_elem.get_simplified_relation().connections)
+            else:
+                raise TypeError(f'unexpected type for inner element `{cur_elem}`')
+        # now our `self_simplified_or_relations` can only consist of the following nesting: `List[OR[Conn, AND[Conn]]]`
+        #  we need to resolve this constellation into `OR[Conn, AND[Conn]]` now
+
+        # now generate all possibilities out of the OR relations and add them to the AND template
+        all_new_ands = []
+        for cur_variation_tuple in itertools.product(*self_simplified_or_relations):
+            for cur_item in cur_variation_tuple:
+                if isinstance(cur_item, Connection):
+                    # just add the single connection item to the AND template
+                    new_full_and_relation = and_template.clone()
+                    new_full_and_relation.append(cur_item)
+                    all_new_ands.append(new_full_and_relation)
+                elif isinstance(cur_item, AndConnectionRelation):
+                    new_full_and_relation = and_template.clone()
+                    new_full_and_relation.extend(cur_item.connections)
+                    all_new_ands.append(new_full_and_relation)
+                else:
+                    #: note: inner element can not be an OR here!
+                    raise TypeError(f'detect illegal type `{cur_item.__class__}` for inner element')
+        if not self_simplified_or_relations:
+            all_new_ands.append(and_template)
+        return OrConnectionRelation(*all_new_ands)
+
+    def is_single(self) -> bool:
+
+        if len(self._connections) == 0:
+            return True
+
+        return min(cnn.is_single() for cnn in self._connections)
+
+    def get_singles(self) -> List[Connection]:
+        from ..connection import Connection  # pylint: disable=import-outside-toplevel
+
+        singles_and_relations = ()
+        for cur_elem in self._connections:
+            # get all singles of this AND relation element
+            singles_and_relations += (cur_elem.get_singles(),)
+        # now get the variations and add them to our results
+        return [
+            Connection.based_on(AndConnectionRelation(*cur_tuple))
+            for cur_tuple in itertools.product(*singles_and_relations)
+        ]
+
+    def cut_into_all_possible_subtree_branches(self) -> List[AndConnectionRelation]:
+        if not self.is_single():
+            raise ValueError('can not execute method, because relation is not single')
+
+        tuple_with_all_possibilities = (
+            tuple(cur_tuple_item.cut_into_all_possible_subtree_branches() for cur_tuple_item in self._connections))
+
+        cloned_tuple_list = []
+        for cur_tuple in list(itertools.product(*tuple_with_all_possibilities)):
+            cloned_tuple = AndConnectionRelation(*[cur_tuple_item.clone() for cur_tuple_item in cur_tuple])
+            cloned_tuple_list.append(cloned_tuple)
+        return cloned_tuple_list
+
+    def contained_in(self, other_conn: Union[Connection, BaseConnectionRelationT], ignore_metadata=False) -> bool:
+        # This method checks if the AND relation is contained in the `other_conn`. To ensure that an AND relation is
+        # contained in a connection tree, there has to be another AND relation into the `other_conn`, that has the same
+        # length or is bigger. In addition, there has to exist an order combination where every element of the this AND
+        # relation is contained in the found AND relation of the `other_cnn`. In this case it doesn't matter where the
+        # AND relation is in `other_elem` (will be converted to single, and AND relation will be searched in all
+        # BASED_ON elements). If the AND relation of `other_conn` has fewer items than this AND relation, it will be
+        # ignored. The method only search for a valid existing item in the `other_conn` AND relation for every item of
+        # this AND relation.
+        from ..connection import Connection  # pylint: disable=import-outside-toplevel
+
+        if not self.is_resolved():
+            raise ValueError('can not execute method, because connection relation is not resolved')
+        if not other_conn.is_resolved():
+            raise ValueError('can not execute method, because other connection relation is not resolved')
+
+        if isinstance(other_conn, BaseConnectionRelation):
+            other_conn = Connection.based_on(other_conn)
+
+        self_singles = self.get_singles()
+        other_singles = other_conn.get_singles()
+
+        for cur_self_single, cur_other_single in itertools.product(self_singles, other_singles):
+            # check if we can find an AND relation in the other object -> go the single connection upwards and
+            # search for a `AndConnectionRelation`
+
+            # self is a container connection -> use raw inner AND list
+            cur_self_single_and_relation = cur_self_single.based_on_elements.connections[0]
+
+            cur_sub_other_single = cur_other_single
+            while cur_sub_other_single is not None:
+                if isinstance(cur_sub_other_single, AndConnectionRelation):
+                    # found an AND relation -> check if length does match
+                    if len(cur_sub_other_single) < len(cur_self_single_and_relation):
+                        # this complete element is not possible - skip this single!
+                        break
+                    # length is okay, no check if every single element is contained in one of this tuple
+                    for cur_inner_self_elem in cur_self_single_and_relation.connections:
+
+                        if not cur_inner_self_elem.contained_in(cur_sub_other_single,
+                                                                ignore_metadata=ignore_metadata):
+                            # at least one element is not contained in other AND relation - this complete element
+                            # is not possible - skip this single!
+                            break
+                    # all items are contained in the current other AND relation -> match
+                    return True
+                # go further up, if this element is no AND relation
+                cur_sub_other_single = cur_sub_other_single.based_on_elements[0] \
+                    if cur_sub_other_single.based_on_elements else None
+
+        return False

baldertest-0.1.0b11/src/_balder/cnnrelations/base_connection_relation.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+from typing import List, Union, Type, Dict, TypeVar, TYPE_CHECKING
+from abc import ABC, abstractmethod
+from ..utils import cnn_type_check_and_convert
+
+if TYPE_CHECKING:
+    from ..connection import Connection
+    from ..connection import ConnectionMetadata
+    from ..device import Device
+    from .and_connection_relation import AndConnectionRelation
+    from .or_connection_relation import OrConnectionRelation
+
+BaseConnectionRelationT = TypeVar('BaseConnectionRelationT', bound='BaseConnectionRelation')
+
+
+class BaseConnectionRelation(ABC):
+    """
+    This is the base connection list class, which provides the general functionality of connection collections.
+    """
+
+    def __init__(self, *connections: Union[Type[Connection], Connection, BaseConnectionRelationT]):
+        self._connections = []
+        # add it over append for type checking
+        for connection in connections:
+            self.append(connection)
+
+    def __iter__(self):
+        return self._connections.__iter__()
+
+    def __getitem__(self, item):
+        return self._connections.__getitem__(item)
+
+    def __len__(self):
+        return len(self._connections)
+
+    def __hash__(self):
+        all_hashes = 0
+        for cur_elem in self.connections:
+            all_hashes += hash(cur_elem) + hash(self.__class__.__name__)
+        return all_hashes
+
+    def __and__(
+            self,
+            other: Union[Connection, Type[Connection], AndConnectionRelation, OrConnectionRelation]
+    ) -> AndConnectionRelation:
+
+        from .and_connection_relation import AndConnectionRelation  # pylint: disable=import-outside-toplevel
+
+        new_list = AndConnectionRelation()
+        new_list.append(self)
+        new_list.append(cnn_type_check_and_convert(other))
+        return new_list
+
+    def __or__(
+            self,
+            other: Union[Connection, Type[Connection], AndConnectionRelation, OrConnectionRelation]
+    ) -> OrConnectionRelation:
+
+        from .or_connection_relation import OrConnectionRelation  # pylint: disable=import-outside-toplevel
+
+        new_list = OrConnectionRelation()
+        new_list.append(self)
+        new_list.append(cnn_type_check_and_convert(other))
+        return new_list
+
+    @property
+    def connections(self) -> List[Union[Connection, BaseConnectionRelationT]]:
+        """
+        returns the components of this connection relation
+        """
+        return self._connections.copy()
+
+    @property
+    def metadata(self) -> ConnectionMetadata | None:
+        """
+        returns the metadata of this connection relation
+        """
+        if not self.connections:
+            return None
+
+        # get all unique metadata objects
+        existing_metadata = list({elem.metadata for elem in self.connections if elem})
+        if len(existing_metadata) > 1:
+            raise ValueError(f'different metadata detected: `{existing_metadata}`')
+        return existing_metadata[0]
+
+    @abstractmethod
+    def get_simplified_relation(self) -> OrConnectionRelation:
+        """
+        This method simplifies the connection relation. It will convert every possible relation into an
+        OrConnectionRelation[Connection, AndConnectionRelation].
+        """
+
+    def clone(self):
+        """
+        clones this connection relation
+        """
+        return self.__class__(*[cnn.clone() for cnn in self._connections])
+
+    def append(self, connection: Union[Type[Connection], Connection, BaseConnectionRelationT]):
+        """
+        appends a component to this connection relation
+        """
+        from ..connection import Connection  # pylint: disable=import-outside-toplevel
+
+        if isinstance(connection, type):
+            if issubclass(connection, Connection):
+                connection = connection()
+            else:
+                raise TypeError(f'can not append a element `{connection.__name__}`')
+        if not isinstance(connection, Connection) and not isinstance(connection, BaseConnectionRelation):
+            raise TypeError('the element that should be appended to the relation needs to be a Connection or another '
+                            'relation')
+        if isinstance(connection, self.__class__):
+            # directly add children (because it has the same type)
+            for cur_inner_connection in connection.connections:
+                self._connections.append(cur_inner_connection)
+        else:
+            self._connections.append(connection)
+
+    def extend(self, relation: BaseConnectionRelationT):
+        """
+        extends the relation with the elements of provided relation
+        """
+        if not isinstance(relation, self.__class__):
+            raise TypeError(f'the relation with the elements that should be appended needs to be from same type (is '
+                            f'`{relation.__class__}` | expected `{self.__class__}`)')
+        for cur_elem in relation.connections:
+            self.append(cur_elem)
+
+    def set_metadata_for_all_subitems(self, metadata: Union[Dict[str, Union[Device, str]], None]):
+        """
+        This method sets the metadata for all existing Connection items in this element.
+
+        :param metadata: the metadata that should be set (if the value is explicitly set to None, it removes the
+                         metadata from every item)
+        """
+        for cur_cnn in self._connections:
+            cur_cnn.set_metadata_for_all_subitems(metadata)
+
+    def get_all_used_connection_types(self) -> List[Type[Connection]]:
+        """
+        This method returns all available connection types, that are used within this connection relation.
+        """
+        from ..connection import Connection  # pylint: disable=import-outside-toplevel
+
+        result = []
+        for cur_inner_elem in self._connections:
+            if isinstance(cur_inner_elem, Connection):
+                result.append(cur_inner_elem.__class__)
+            elif isinstance(cur_inner_elem, BaseConnectionRelation):
+                result.extend(cur_inner_elem.get_all_used_connection_types())
+            else:
+                raise TypeError(f'unexpected type for inner item `{cur_inner_elem.__class__.__name__}`')
+        return list(set(result))
+
+    @abstractmethod
+    def get_tree_str(self) -> str:
+        """
+        returns the tree string for this part of the connection tree
+        """
+
+    def is_resolved(self) -> bool:
+        """
+        returns whether this connection relation is part of a single connection
+        """
+        if len(self._connections) == 0:
+            return True
+        return min(cnn.is_resolved() for cnn in self._connections)
+
+    def get_resolved(self) -> BaseConnectionRelationT:
+        """
+        This method returns a resolved Connection Tree. This means that it convert the based_on references so that
+        every based on connection is a direct parent of the current element. It secures that there are no undefined
+        connection layers between an object and the given parent.
+        """
+        return self.__class__(*[cnn.get_resolved() for cnn in self._connections])
+
+    @abstractmethod
+    def is_single(self) -> bool:
+        """
+        returns whether this connection relation is part of a single connection
+        """
+
+    @abstractmethod
+    def get_singles(self) -> List[Connection]:
+        """
+        returns the single connections of all components of this connection relation
+        """
+
+    def cnn_are_in_other(self, other: BaseConnectionRelationT, ignore_metadata: bool=False) -> bool:
+        """
+        This method validates that the elements from this relation are contained in the other relation. Elements matches
+        with each other, as soon as they are equal.
+
+        .. 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 other: the first list of connections
+        :param other: the other relation object
+        :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 self._connections:
+            found_equal = False
+            for cur_other_cnn in other.connections:
+                if cur_cnn.equal_with(cur_other_cnn, ignore_metadata=ignore_metadata):
+                    found_equal = True
+                    break
+            if not found_equal:
+                return False
+        return True
+
+    @abstractmethod
+    def cut_into_all_possible_subtree_branches(self):
+        """
+        This method returns a list of all possible connection tree branches. A branch is a single connection, while
+        this method returns a list of all possible singles where every single connection has this connection as head.
+        """
+
+    def equal_with(self, other_relation: BaseConnectionRelationT, ignore_metadata=False) -> bool:
+        """
+        This method returns True if the current relation matches with the other relation object. It always converts the
+        elements to a resolved version and checks if both of them are exactly the same.
+
+        .. note::
+            Note that both connection relations need to be resolved.
+
+        .. note::
+            Note that both Connection objects have to have the same ending parent elements. Only the order of the inner
+            connection elements are irrelevant.
+
+        :param other_relation: the other connection relation (needs to be the same type)
+
+        :param ignore_metadata: if this value is true the method ignores the metadata
+
+        :return: returns True if both elements are same
+        """
+        if self.__class__ != other_relation.__class__:
+            return False
+
+        if not self.is_resolved():
+            raise ValueError('can not execute method, because connection relation is not resolved')
+        if not other_relation.is_resolved():
+            raise ValueError('can not execute method, because other connection relation is not resolved')
+
+        # check inner connection elements (if they match all in both directions)
+        return (self.cnn_are_in_other(other_relation, ignore_metadata=ignore_metadata)
+                and other_relation.cnn_are_in_other(self, ignore_metadata=ignore_metadata))
+
+    @abstractmethod
+    def contained_in(self, other_conn: Union[Connection, BaseConnectionRelationT], ignore_metadata=False) -> bool:
+        """
+        This method helps to find out whether this connection relation fits within a given connection tree. A connection
+        object is a certain part of the large connection tree that Balder has at its disposal. This method checks
+        whether a possibility of this connection tree fits in one possibility of the given connection tree.
+
+        .. note::
+            The method returns true if one single connection of this object fits in another single connection that is
+            given by `other_conn`.
+
+        :param other_conn: the other connection
+
+        :param ignore_metadata: if this value is true the method ignores the metadata
+
+        :return: true if the self object is contained in the `other_conn`, otherwise false
+        """