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

_balder/controllers/normal_scenario_setup_controller.py

@@ -7,6 +7,7 @@ from abc import ABC, abstractmethod
 from _balder.setup import Setup
 from _balder.device import Device
 from _balder.scenario import Scenario
+from _balder.connection_metadata import ConnectionMetadata
 from _balder.controllers.controller import Controller
 from _balder.controllers.device_controller import DeviceController
 from _balder.controllers.vdevice_controller import VDeviceController
@@ -374,11 +375,10 @@ class NormalScenarioSetupController(Controller, ABC):
                         all_devices[all_devices_as_strings.index(cur_parent_cnn.from_device.__name__)]
                     related_to_device = all_devices[all_devices_as_strings.index(cur_parent_cnn.to_device.__name__)]
                     new_cnn = cur_parent_cnn.clone()
-                    new_cnn.set_metadata_for_all_subitems(None)
-                    new_cnn.set_metadata_for_all_subitems(
-                        {"from_device": related_from_device, "to_device": related_to_device,
-                         "from_device_node_name": cur_parent_cnn.from_node_name,
-                         "to_device_node_name": cur_parent_cnn.to_node_name})
+                    new_cnn.set_metadata_for_all_subitems(ConnectionMetadata(
+                        from_device=related_from_device, from_device_node_name=cur_parent_cnn.from_node_name,
+                        to_device=related_to_device, to_device_node_name=cur_parent_cnn.to_node_name)
+                    )
                     all_relevant_cnns.append(new_cnn)
 
                 # throw warning (but only if this scenario/setup has minimum one of the parent classes has inner

_balder/controllers/scenario_controller.py

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

_balder/controllers/setup_controller.py

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

_balder/decorator_connect.py

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

_balder/decorator_for_vdevice.py

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

_balder/decorator_gateway.py

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

_balder/executor/testcase_executor.py

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