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

_balder/feature.py

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

_balder/feature_replacement_mapping.py

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

_balder/feature_vdevice_mapping.py

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

_balder/fixture_manager.py

@@ -1,4 +1,6 @@
 from __future__ import annotations
+
+import itertools
 from typing import List, Tuple, Generator, Dict, Union, Type, Callable, Iterable, TYPE_CHECKING
 
 import inspect
@@ -374,15 +376,14 @@ class FixtureManager:
             if cur_arg in ignore_attributes:
                 continue
             # go to the most specific fixture, because more specific ones overwrite the more global ones
-            for cur_possible_namespace in all_possible_namespaces:
-                for cur_level in FixtureExecutionLevel:
-                    if cur_level not in self.current_tree_fixtures.keys():
-                        continue
-                    # filter only these fixtures that have the same namespace
-                    for cur_fixture_metadata in self.current_tree_fixtures[cur_level]:
-                        if (cur_fixture_metadata.namespace == cur_possible_namespace
-                                and cur_fixture_metadata.callable.__name__ == cur_arg):
-                            result_dict[cur_arg] = cur_fixture_metadata.retval
+            for cur_possible_namespace, cur_level in itertools.product(all_possible_namespaces, FixtureExecutionLevel):
+                if cur_level not in self.current_tree_fixtures.keys():
+                    continue
+                # filter only these fixtures that have the same namespace
+                for cur_fixture_metadata in self.current_tree_fixtures[cur_level]:
+                    if (cur_fixture_metadata.namespace == cur_possible_namespace
+                            and cur_fixture_metadata.callable.__name__ == cur_arg):
+                        result_dict[cur_arg] = cur_fixture_metadata.retval
             if cur_arg not in result_dict.keys():
                 raise FixtureReferenceError(
                         f"the argument `{cur_arg}` in fixture `{callable_func.__qualname__}` could not be resolved")

_balder/objects/connections/osi_3_network.py

@@ -20,7 +20,7 @@ class IPv6Connection(Connection):
     """
 
 
-IPConnection = Connection.based_on(IPv4Connection, IPv6Connection)
+IPConnection = Connection.based_on(IPv4Connection | IPv6Connection)
 
 
 @insert_into_tree(parents=[IPv4Connection, IPv6Connection])
@@ -44,4 +44,4 @@ class ICMPv6Connection(Connection):
     """
 
 
-ICMPConnection = Connection.based_on(ICMPv4Connection, ICMPv6Connection)
+ICMPConnection = Connection.based_on(ICMPv4Connection | ICMPv6Connection)

_balder/objects/connections/osi_4_transport.py

@@ -20,7 +20,7 @@ class TcpIPv6Connection(Connection):
     """
 
 
-TcpConnection = Connection.based_on(TcpIPv4Connection, TcpIPv6Connection)
+TcpConnection = Connection.based_on(TcpIPv4Connection | TcpIPv6Connection)
 
 
 @insert_into_tree(parents=[osi_3_network.IPv4Connection])
@@ -37,4 +37,4 @@ class UdpIPv6Connection(Connection):
     """
 
 
-UdpConnection = Connection.based_on(UdpIPv4Connection, UdpIPv6Connection)
+UdpConnection = Connection.based_on(UdpIPv4Connection | UdpIPv6Connection)

_balder/routing_path.py

@@ -79,17 +79,13 @@ class RoutingPath:
         if alternative_setup_device_cnns is None:
             setup_devices_cnns = []
             for cur_setup_device in device_mapping.values():
-                cur_setup_device_abs_cnns = \
-                    DeviceController.get_for(cur_setup_device).get_all_absolute_connections()
-                for _, cur_cnn_list in cur_setup_device_abs_cnns.items():
-                    for cur_cnn in cur_cnn_list:
-                        if cur_cnn not in setup_devices_cnns:
-                            setup_devices_cnns.append(cur_cnn)
-
-        from_scenario_device = scenario_connection.from_device
-        to_scenario_device = scenario_connection.to_device
-        from_setup_device = device_mapping[from_scenario_device]
-        to_setup_device = device_mapping[to_scenario_device]
+                for cur_cnn_list in DeviceController.get_for(cur_setup_device).get_all_absolute_connections().values():
+                    setup_devices_cnns.extend(cur_cnn_list)
+            # remove duplicates
+            setup_devices_cnns = list(set(setup_devices_cnns))
+
+        from_setup_device = device_mapping[scenario_connection.from_device]
+        to_setup_device = device_mapping[scenario_connection.to_device]
 
         # contains a list with all routes that start and end correctly
         all_completed_routes = []
@@ -100,27 +96,28 @@ class RoutingPath:
         for cur_from_setup_node_conn in setup_devices_cnns:
             # only if there is a connection outgoing from `from_setup_device`
             if cur_from_setup_node_conn.has_connection_from_to(start_device=from_setup_device):
-                cur_from_setup_node = cur_from_setup_node_conn.from_node_name \
-                    if cur_from_setup_node_conn.from_device == from_setup_device \
-                    else cur_from_setup_node_conn.to_node_name
-                new_route = RoutingPath(cur_from_setup_node_conn, start_device=from_setup_device,
-                                        start_node_name=cur_from_setup_node)
-                all_possible_routes.append(new_route)
+                all_possible_routes.append(
+                    RoutingPath(
+                        cur_from_setup_node_conn,
+                        start_device=from_setup_device,
+                        start_node_name=(cur_from_setup_node_conn.from_node_name
+                                         if cur_from_setup_node_conn.from_device == from_setup_device
+                                         else cur_from_setup_node_conn.to_node_name)
+                    )
+                )
         # now go through every possibility and add them - filter all Routes that ``has_loop() == True`` or
         # are completed
         while len(all_possible_routes) > 0:
 
             # remove all routings that have a loop
-            for cur_routing in all_possible_routes.copy():
-                if cur_routing.has_loop():
-                    all_possible_routes.remove(cur_routing)
+            all_possible_routes = [route for route in all_possible_routes.copy() if not route.has_loop()]
 
-            # remove all routings which do not work because they have the wrong connection type
-            for cur_routing in all_possible_routes.copy():
-                # check that one part connection matches the requirements of the given `scenario_connection`
-                if not scenario_connection.contained_in(cur_routing.get_virtual_connection(), ignore_metadata=True):
-                    # the virtual connection doesn't match the requirement -> delete possibility
-                    all_possible_routes.remove(cur_routing)
+            # remove all not working routing because they have the wrong connection type, by checking that one part
+            # connection matches the requirements of the given `scenario_connection`
+            all_possible_routes = [
+                r for r in all_possible_routes
+                if scenario_connection.contained_in(r.get_virtual_connection(), ignore_metadata=True)
+            ]
 
             # move all completely routed connections to `all_completed_routes`
             for cur_routing in all_possible_routes.copy():
@@ -167,7 +164,7 @@ class RoutingPath:
     # ---------------------------------- PROPERTIES --------------------------------------------------------------------
 
     @property
-    def elements(self) -> List[Connection, NodeGateway]:
+    def elements(self) -> List[Union[Connection, NodeGateway]]:
         """returns all elements that belongs to this routing path"""
         return self._routing_elems
 
@@ -269,7 +266,7 @@ class RoutingPath:
         """
         copied_elem = copy.copy(self)
         # also copy list reference
-        copied_elem._routing_elems = self._routing_elems.copy()
+        copied_elem._routing_elems = self._routing_elems.copy()  # pylint: disable=protected-access
         return copied_elem
 
     def append_element(self, elem: Union[Connection, NodeGateway]) -> None:
@@ -324,8 +321,7 @@ class RoutingPath:
                 # todo
                 pass
         # set metadata based on this routing
-        virtual_connection.set_devices(from_device=self.start_device, to_device=self.end_device)
-        virtual_connection.update_node_names(from_device_node_name=self.start_node_name,
-                                             to_device_node_name=self.end_node_name)
+        virtual_connection.metadata.set_from(from_device=self.start_device, from_device_node_name=self.start_node_name)
+        virtual_connection.metadata.set_to(to_device=self.end_device, to_device_node_name=self.end_node_name)
 
         return virtual_connection

_balder/solver.py

@@ -117,7 +117,7 @@ class Solver:
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
-    def get_initial_mapping(self) -> List[Tuple[Type[Setup], Type[Scenario], Dict[Device, Device]]]:
+    def get_initial_mapping(self) -> List[Tuple[Type[Setup], Type[Scenario], Dict[Type[Device], Type[Device]]]]:
         """
         This method creates the initial amount of data for `self._mapping`. Only those elements are returned where the
         :meth:`Setup` class has more or the same amount of :meth:`Device`'s than the :meth:`Scenario` class.

_balder/testresult.py

@@ -95,7 +95,7 @@ class BranchBodyResult(_Result):
     """
 
     def __init__(self, executor: BasicExecutor):
-        from _balder.executor.testcase_executor import TestcaseExecutor
+        from _balder.executor.testcase_executor import TestcaseExecutor  # pylint: disable=import-outside-toplevel
 
         if isinstance(executor, TestcaseExecutor):
             raise TypeError("testcase executors are not allowed to use in `BranchBodyResult`")

_balder/utils.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, Type, Tuple, Union, Literal
+from typing import List, Type, Tuple, Union, Literal, TYPE_CHECKING
 
 import sys
 import inspect
@@ -8,6 +8,10 @@ from _balder.exceptions import InheritanceError
 
 MethodLiteralType = Literal["function", "classmethod", "staticmethod", "instancemethod"]
 
+if TYPE_CHECKING:
+    from _balder.connection import Connection
+    from _balder.cnnrelations.base_connection_relation import BaseConnectionRelationT
+
 
 def get_scenario_inheritance_list_of(scenario: Type[Scenario]) -> List[Type[Scenario]]:
     """
@@ -45,6 +49,28 @@ def get_class_that_defines_method(meth):
     return None  # not required since None would have been implicitly returned anyway
 
 
+def cnn_type_check_and_convert(elem: Union[Connection, Type[Connection], BaseConnectionRelationT]) \
+        -> Union[Connection, BaseConnectionRelationT]:
+    """
+    converts possible type object to instance and checks if the element is a connection type
+
+    :param elem: the connection object to be converted/checked
+    """
+
+    from .connection import Connection  # pylint: disable=import-outside-toplevel
+    from .cnnrelations.and_connection_relation import AndConnectionRelation  # pylint: disable=import-outside-toplevel
+    from .cnnrelations.or_connection_relation import OrConnectionRelation  # pylint: disable=import-outside-toplevel
+
+    if isinstance(elem, type):
+        if issubclass(elem, Connection):
+            return elem()
+    elif isinstance(elem, (Connection, AndConnectionRelation, OrConnectionRelation)):
+        # okay
+        return elem
+    raise TypeError(f'object needs to be a `Connection`, a connection relation or a `Type[Connection]` - no '
+                    f'`{elem}`')
+
+
 def inspect_method(func) -> Tuple[Union[type, None], MethodLiteralType]:
     """
     This helper function returns the related class and the type of the method (`staticmethod`, `classmethod`,

{baldertest-0.1.0b10.dist-info → baldertest-0.1.0b12.dist-info}/METADATA

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

{baldertest-0.1.0b10.dist-info → baldertest-0.1.0b12.dist-info}/RECORD

@@ -1,48 +1,55 @@
 _balder/__init__.py,sha256=Qk4wkVInPlXLFV36Yco5K7PDawJoeeWQVakzj6g5pmA,195
-_balder/_version.py,sha256=VMQ9RsEJj3xjqPNgKf0AjBlaGisX_Y8yqdE9FG2S_e4,414
+_balder/_version.py,sha256=S15DTS8dk0LprNo0fc6N8N7MUlyHFciSG3FMI5y2iZE,414
 _balder/balder_plugin.py,sha256=EQzJP1dwwVDydhMLJtAmTCXOczlDuXBJur05lalmK_k,3136
 _balder/balder_session.py,sha256=ezT86gC_VzPQZOQ4r5qQ75IEm6rXZHiIpEqZDczkRsE,16149
 _balder/balder_settings.py,sha256=U96PVep7dGSaTXrMfeZMYf6oCIcEDPEqrBlFcoX476s,582
-_balder/collector.py,sha256=7aIxU2cUDKNHDUyU8yzoUrkC1CqVijTOJbOQqLe6T9w,48043
-_balder/connection.py,sha256=MNazK97CIEJCA4o1krjKjtilVhOYMWD8TZT0YT5nCJs,71778
-_balder/decorator_connect.py,sha256=TvyJNIslBAYVQWhsfSeFgXKp_DP7sZF1BmcP6RhIdKo,5988
+_balder/collector.py,sha256=uymS7CwymrZNxzKDG9_kPOK7HGKtnX3FNwX7Dk2LuC0,47567
+_balder/connection.py,sha256=j6wI7m3h23q9aCApRDmLyeerxUXQ0j267v4FgjP4p6E,41770
+_balder/connection_metadata.py,sha256=FrTj6NNBBUl6QuFx8DWy6HRueufXB93WTBkdc41uFaE,13632
+_balder/decorator_connect.py,sha256=67CojFZH9dZ_qwnvb6rkqxe3adtQlgHVi_0etmP5Hyw,5881
 _balder/decorator_covered_by.py,sha256=Y6WMUuyn_uvFkjGfbts8OE5Bsir_7LTRB-jxYGaYk4Y,4069
 _balder/decorator_fixture.py,sha256=vVd3pXVWEaaVP2rxgW4nKoskmDByafHuSFHC0v_LMoI,1045
-_balder/decorator_for_vdevice.py,sha256=HvK8-cVVUojlVYk0hh8F03cMGsiVfpP99IQbIgJOS5Q,6506
-_balder/decorator_gateway.py,sha256=w6-1UFh8ydt81U6ymGxeBUFAIh2aaZ3U9pHpEANMlj8,1284
+_balder/decorator_for_vdevice.py,sha256=adEzLc0otuvCpj2TntuJWMQX_mq2oLtYRXFFbIhQVYo,5917
+_balder/decorator_gateway.py,sha256=Qa8Cjm50I1OSHhADU8LmeSQh2QSuH9qGRuedWAlLfu4,1381
 _balder/decorator_insert_into_tree.py,sha256=l3nkaTzKzt3TIFYLJoehYwT3xxRRNz83fq8JhvR6DfQ,2069
 _balder/decorator_parametrize.py,sha256=lHxADbHZVnWOhvQTUQgaYU1hQ8NF3ghMU57Z3r_oWVE,912
 _balder/decorator_parametrize_by_feature.py,sha256=r0iySfWcFxXIVu0BNWIRU_E6_o2-lSzpL5aUifoqiyU,1381
 _balder/device.py,sha256=5O3tqj_iLKfHb5Zi_viJ76VH82cMOzX58OzRrMRRv0k,833
 _balder/exceptions.py,sha256=_zQFUK4kYKaVGUtH9IcH0q-GOyBb9qzqSU6BOsUnG7Y,4375
 _balder/exit_code.py,sha256=P0oFWKfjMo36Frv13ADRcm8eSPN3kE-WmZBE9qZJHdA,513
-_balder/feature.py,sha256=B3yPc-WZwLt1Q4dO9s2j9g1MBTcMBjn6oWoLnRgrwSs,3845
+_balder/feature.py,sha256=Da6BP4H1X0eKm0DyQKRdSnrQeqV8QeCFE4JybI_wYSc,3888
+_balder/feature_replacement_mapping.py,sha256=fCUnWY3pSJqPrdN_kA4jzkfzx7UYSkBDm6NbC2A522c,2766
+_balder/feature_vdevice_mapping.py,sha256=aAQ8R48orYiOr_9_L8nZCz3jq5-qlq9gfY7DeTzmUyM,3576
 _balder/fixture_definition_scope.py,sha256=0MP0U2fcM9iS28Ytkfuu3TzZ4cUNG5u81GBWGBm9ucw,709
 _balder/fixture_execution_level.py,sha256=-y7-4bihTSMzhYvM2O1Qc40ovyvW7SP25rHvWHZpD6g,655
-_balder/fixture_manager.py,sha256=p5FzklRTlgN0UHbFkLru2M664y17oAafvKQwNqaEzKk,29240
+_balder/fixture_manager.py,sha256=RjAQjpvBBGy-loCVCHlkArvyr35rr4shNWUpeY-0QP4,29227
 _balder/fixture_metadata.py,sha256=4vls8-I0bsRxLDNbD5Du4Cm2ZPYwxqfuSeEY6D654jE,872
 _balder/node_gateway.py,sha256=64mv7Nx82JVknnQ09UXC-AcdDl6i_OB6NOsq_uBxeYo,4710
 _balder/parametrization.py,sha256=SnaGeGpf7-5H-y107CBDx5V-onX-oiLS1KU1IquZwcU,2678
 _balder/plugin_manager.py,sha256=Ev2jnx4NtFHDsZ3C6h0HrJtQisqLO-V34JRM3wzTnFM,6921
 _balder/previous_executor_mark.py,sha256=gwpGu7d-kwPzQT8CmaPfuEG6fess2Upf5Q-zX6Oi6NY,835
-_balder/routing_path.py,sha256=6MJkhzBTHow2ESXzKQ2otwRFbPcKhLTYVy-zh7c5HeE,17172
+_balder/routing_path.py,sha256=pyPaLD_-SyX3PZDWI6BUHHrIIPg3k5swfxFI6ncf2iA,16803
 _balder/scenario.py,sha256=ATowBUl2HYQBmJHZ-eBpliqjPsWPnZAme9kwIeX3Tak,840
 _balder/setup.py,sha256=zSgtzNIWTVBjiZ5mn-qfpqIAnP3Im73t3Lqoaw0gWEI,763
-_balder/solver.py,sha256=S4FDYY6q4s5wJeQlRVZpa_DXXVxAKsbQkspR5EX3OCA,13109
-_balder/testresult.py,sha256=byJD3F84TNH40k30pjnxeLHXAAE-lqbVlk1JOSBtdNo,6783
+_balder/solver.py,sha256=NbpAdvrGWdJTY6eZmNZFr7YDubyggY0yW64rDB3JkT0,13121
+_balder/testresult.py,sha256=Tm5m0Rnpn3JgdQp22izsMIPoVxRU0ngJjUuS73eRboM,6826
 _balder/unmapped_vdevice.py,sha256=oKr01YVTLViWtZkYz8kx8ccTx-KmwgNrHuQqqD4eLQw,513
-_balder/utils.py,sha256=2kcX6bZIJW9Z8g-Hv0ue2mdOLBQYq4T2XSZpH2in1MQ,3092
+_balder/utils.py,sha256=7bfjap7KKpFaRFusCimMpk-UYR4X1LR-pdA_q7DN28E,4271
 _balder/vdevice.py,sha256=fc2xuMnTuN1RyfWh9mqFgLdSO9yGA75eERobTXUQ9JA,215
+_balder/cnnrelations/__init__.py,sha256=LDnjVlJmclxmfKs3snKsK2RDMg8N7Xc6OeDVioxHR58,187
+_balder/cnnrelations/and_connection_relation.py,sha256=mrio_jyMuJ2VmJtiFAKQ8BMqjHYiKIpWmuc4KpgcIMM,8048
+_balder/cnnrelations/base_connection_relation.py,sha256=s9DufjB9EHkqVUHhjDurMGiPxtTte-yvwCQ2nFAHZeY,11402
+_balder/cnnrelations/or_connection_relation.py,sha256=hPqC86qXRRgaOA6SeIzGnqxY6zd9OJ1KU5jwKbERo7s,2730
 _balder/console/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _balder/console/balder.py,sha256=rF1qgW6h35hKqGijGbZgGD2_y0Sd9Mbs_EXF2v_EUCk,2581
 _balder/controllers/__init__.py,sha256=UNb6QzMj4TqPI15OSvXyUJlA-NSai0CKkQhV5JIsba0,570
 _balder/controllers/base_device_controller.py,sha256=g-vY2SqKFUC9yGOvHLfbdmILT3sK2YyaWKSfvTRcC0o,3174
 _balder/controllers/controller.py,sha256=XGRE5LKWxxftEf-bZODvKxXwULu09iG131wMwRoz4Fk,803
-_balder/controllers/device_controller.py,sha256=6ndZmFdC1XEQ540CQxHEDa4ibSZhe94iZPZ0ZtmnFos,23477
-_balder/controllers/feature_controller.py,sha256=jaIbKbiEOdYRpYWuGdaByQBtlThK-u7OAr_xYhAfnEg,43737
-_balder/controllers/normal_scenario_setup_controller.py,sha256=bWR8GOGoRQ0B_sbLSX-u9IjHzvC3xcYRRSJfvQPQ-aY,21928
-_balder/controllers/scenario_controller.py,sha256=CNJikLNNYECs1vFyJDG_dwJwtaT_o2kziFeXQzVSQuE,22405
-_balder/controllers/setup_controller.py,sha256=iNIMFjawYJWaSToUUfpmRK6ssycPyZGNlcvms8c7GKM,7135
+_balder/controllers/device_controller.py,sha256=_Leg_qYnuAQGVmqO77oJOm77EXSYRi7I1e38ZevgcEw,24343
+_balder/controllers/feature_controller.py,sha256=ve7t9zwhkPP-L_LZbKghdD6An2LO2TYWErAfN9dfRdQ,41405
+_balder/controllers/normal_scenario_setup_controller.py,sha256=w7VBxnrFu7_NBeTRD-XZBRflBjA8MPD_aL0DTh7w_pU,21924
+_balder/controllers/scenario_controller.py,sha256=sfCpR4NfWgEIksVV3dP8gko95vu_6FBMseU5Pb_CBZk,22354
+_balder/controllers/setup_controller.py,sha256=1jX_K_7iHQ2jWBZv-urC0_9lCi4RjrwxvtW7oWMVb7s,7082
 _balder/controllers/vdevice_controller.py,sha256=6-PidCKgvUteZVJsbGkKX69f3cYYYnolONl5Gja16W8,5777
 _balder/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _balder/executor/basic_executable_executor.py,sha256=Mta7a9stCiKPMQ6Hafe4jhlhLSeP6Bk7EWIPXUzrwNE,5135
@@ -51,15 +58,15 @@ _balder/executor/executor_tree.py,sha256=I3zy5qOrQWoT3_3YnGDvGvfJE829J0X9xT7WtSr
 _balder/executor/parametrized_testcase_executor.py,sha256=uR_CwdIRxiL1vqJP2P2htc0JPPevMGarIQs7cqHNzmU,2106
 _balder/executor/scenario_executor.py,sha256=3-CkamjyIatDxS3INcYGTXDOtGR-bokcMLaMxC10Ytg,11344
 _balder/executor/setup_executor.py,sha256=Icn-b3MHLMCGGOIGAPB01KWC6LkkZ-ikD_0XqcQjK0Y,8570
-_balder/executor/testcase_executor.py,sha256=EZAPus0hsWJwHlqc7rEyULV8Ue2pyCwoOR1jLsbIQGA,7816
+_balder/executor/testcase_executor.py,sha256=xSOjDexvcUET6vfwn1ogOs1Xi-9yeCt2AsnivXZkTao,7702
 _balder/executor/unresolved_parametrized_testcase_executor.py,sha256=nwScqqiJD7Clkk3YcrPqXJnGEWjvunAlUYAwYvpUI2s,9075
-_balder/executor/variation_executor.py,sha256=6wApsXwzt7dxZkL6hTIMYVL5NQX7dW8IubgtU5AJPo4,54314
+_balder/executor/variation_executor.py,sha256=PBkhNvucf7oPIrDiFSbcy8f7g-KfLOKMLSfTWAuCDVk,53093
 _balder/objects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _balder/objects/connections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _balder/objects/connections/osi_1_physical.py,sha256=74lKWJd6ETEtvNXH0_dmTbkZlStJ_af218pQkUht0aA,2189
 _balder/objects/connections/osi_2_datalink.py,sha256=0k1imyx6x_YeSvtf5CG27rcLeDzpmz76DUbjWyIGJqg,875
-_balder/objects/connections/osi_3_network.py,sha256=qbDAIdgvQu7gs_BTYKeWug3bSWLVDPX2-W57I5Tygw0,1173
-_balder/objects/connections/osi_4_transport.py,sha256=dXp4pbEK6VW9FaKQbH1utEEfut-XwlwEX0h2xVSts3k,981
+_balder/objects/connections/osi_3_network.py,sha256=7s4gEYxR38LE3yUTPoDaYT6kJiWBQdcU9OBFO29E2j0,1175
+_balder/objects/connections/osi_4_transport.py,sha256=9INPME_TWiZQ9rXUzIV__yOPsLQXcdf-7F336WijFOo,983
 _balder/objects/connections/osi_5_session.py,sha256=cMSIBMGk80VSgmFdqWaYI3HQLOvJHi4uTaqDMqWaU5Q,390
 _balder/objects/connections/osi_6_presentation.py,sha256=zCQXocR14CC8rFONFHUethvsoHh4b92e0CC3nLDqNZs,394
 _balder/objects/connections/osi_7_application.py,sha256=VPTlKKCEd9FFusce2wVbScIBPzpikPQtpSPE7PHxMUI,2304
@@ -70,9 +77,9 @@ balder/connections.py,sha256=H6rf7UsiVY_FeZLngZXCT9WDw9cQqpiDiPbz_0J4yjM,2331
 balder/devices.py,sha256=zupHtz8yaiEjzR8CrvgZU-RzsDQcZFeN5mObfhtjwSw,173
 balder/exceptions.py,sha256=iaR4P2L7K3LggYSDnjCGLheZEaGgnMilxDQdoYD5KHQ,1954
 balder/parametrization.py,sha256=R8U67f6DEnXdDc9cGOgS8yFTEAfhglv1v9mnAUAExUg,150
-baldertest-0.1.0b10.dist-info/LICENSE,sha256=Daz9qTpqbiq-klWb2Q9lYOmn3rJ5oIQnbs62sGcqOZ4,1084
-baldertest-0.1.0b10.dist-info/METADATA,sha256=CxZJgsDYz6akqzwst785srtsXfO8F0PylLbV1Ylujao,15784
-baldertest-0.1.0b10.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-baldertest-0.1.0b10.dist-info/entry_points.txt,sha256=hzqu_nrMKTCi5IJqzS1fhIXWEiL7mTGZ-kgj2lUYlRU,65
-baldertest-0.1.0b10.dist-info/top_level.txt,sha256=RUkIBkNLqHMemx2C9aEpoS65dpqb6_jU-oagIPxGQEA,15
-baldertest-0.1.0b10.dist-info/RECORD,,
+baldertest-0.1.0b12.dist-info/LICENSE,sha256=Daz9qTpqbiq-klWb2Q9lYOmn3rJ5oIQnbs62sGcqOZ4,1084
+baldertest-0.1.0b12.dist-info/METADATA,sha256=UmZEcpV1c0RcuZGHol2Q08Z5OPKkcYop47aM2iPjBoU,15784
+baldertest-0.1.0b12.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+baldertest-0.1.0b12.dist-info/entry_points.txt,sha256=hzqu_nrMKTCi5IJqzS1fhIXWEiL7mTGZ-kgj2lUYlRU,65
+baldertest-0.1.0b12.dist-info/top_level.txt,sha256=RUkIBkNLqHMemx2C9aEpoS65dpqb6_jU-oagIPxGQEA,15
+baldertest-0.1.0b12.dist-info/RECORD,,

{baldertest-0.1.0b10.dist-info → baldertest-0.1.0b12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any