Actor revalidation

dff/pipeline/pipeline/actor.py

@@ -22,8 +22,9 @@
 
 .. figure:: /_static/drawio/dfe/user_actor.png
 """
+import inspect
 import logging
-from typing import Union, Callable, Optional, Dict, List, Any, ForwardRef
+from typing import Tuple, Union, Callable, Optional, Dict, List, Any, ForwardRef, Type
 import copy
 
 from dff.utils.turn_caching import cache_clear
@@ -32,7 +33,7 @@
 
 from dff.script.core.context import Context
 from dff.script.core.script import Script, Node
-from dff.script.core.normalization import normalize_label, normalize_response
+from dff.script.core.normalization import normalize_label
 from dff.script.core.keywords import GLOBAL, LOCAL
 
 logger = logging.getLogger(__name__)
@@ -56,6 +57,79 @@ def error_handler(error_msgs: list, msg: str, exception: Optional[Exception] = N
         logger.error(msg, exc_info=exception)
 
 
+def types_match(type1: Type, type2: Type) -> bool:
+    """
+    This function compares types with assumption that one of the types might be a :py:class:`typing.ForwardRef`.
+    If it is so, it compares type and forward reference by name.
+
+    :param type1: First type to compare.
+    :param type2: Second type to compare.
+    :return: True if types are equal, False otherwise.
+    """
+    if type1 == type2:
+        return True
+    elif type(type1) is ForwardRef or type(type2) is ForwardRef:
+        type1_name = type1.__forward_arg__ if type(type1) is ForwardRef else type1.__name__
+        type2_name = type2.__forward_arg__ if type(type2) is ForwardRef else type2.__name__
+        return type1_name == type2_name
+    else:
+        return False
+
+
+def validate_callable(
+    callable: Callable,
+    name: str,
+    flow_label: str,
+    node_label: str,
+    error_msgs: list,
+    logging_flag: bool = True,
+    expected_types: Optional[List[Type]] = None,
+    return_type: Optional[Tuple[Type]] = None,
+):
+    """
+    This function validates a function during :py:class:`~dff.script.Script` validation.
+    It checks parameter number (unconditionally), parameter types (if specified) and return type (if specified).
+
+    :param callable: Function to validate.
+    :param name: Type of the function (label, condition, response, etc.).
+    :param flow_label: Flow label this function is related to (used for error localization only).
+    :param node_label: Node label this function is related to (used for error localization only).
+    :param error_msgs: List that contains error messages. All the error message will be added to that list.
+    :param logging_flag: The flag which defines whether logging is necessary. Defaults to `True`.
+    :param expected_types: List of types that correspond to expected function parameter types.
+        Also used for parameter number check. If `None`, parameter check is skipped. Defaults to `None`.
+    :param return_type: Tuple, containing expected function return type.
+        If `None` or contains more or less than 1 element, return type check is skipped. Defaults to `None`.
+    """
+    signature = inspect.signature(callable)
+    if expected_types is not None:
+        params = list(signature.parameters.values())
+        if len(params) != len(expected_types):
+            msg = (
+                f"Incorrect parameter number of {name}={callable.__name__}: "
+                f"should be {len(expected_types)}, found {len(params)}, "
+                f"error was found in (flow_label, node_label)={(flow_label, node_label)}"
+            )
+            error_handler(error_msgs, msg, None, logging_flag)
+        for idx, param in enumerate(params):
+            if param.annotation != inspect.Parameter.empty and not types_match(param.annotation, expected_types[idx]):
+                msg = (
+                    f"Incorrect {idx} parameter annotation of {name}={callable.__name__}: "
+                    f"should be {expected_types[idx]}, found {param.annotation}, "
+                    f"error was found in (flow_label, node_label)={(flow_label, node_label)}"
+                )
+                error_handler(error_msgs, msg, None, logging_flag)
+    if return_type is not None and len(return_type) == 1:
+        retrun_annotation = signature.return_annotation
+        if retrun_annotation != inspect.Parameter.empty and not types_match(retrun_annotation, return_type[0]):
+            msg = (
+                f"Incorrect return type annotation of {name}={callable.__name__}: "
+                f"should be {return_type[0]}, found {retrun_annotation}, "
+                f"error was found in (flow_label, node_label)={(flow_label, node_label)}"
+            )
+            error_handler(error_msgs, msg, None, logging_flag)
+
+
 class Actor:
     """
     The class which is used to process :py:class:`~dff.script.Context`
@@ -87,11 +161,11 @@ def __init__(
         condition_handler: Optional[Callable] = None,
         handlers: Optional[Dict[ActorStage, List[Callable]]] = None,
     ):
-        # script validation
+        # script evaluation
         self.script = script if isinstance(script, Script) else Script(script=script)
         self.label_priority = label_priority
 
-        # node labels validation
+        # node labels evaluation
         self.start_label = normalize_label(start_label)
         if self.script.get(self.start_label[0], {}).get(self.start_label[1]) is None:
             raise ValueError(f"Unknown start_label={self.start_label}")
@@ -325,68 +399,106 @@ def _choose_label(
             chosen_label = self.fallback_label
         return chosen_label
 
-    def validate_script(self, pipeline: Pipeline, verbose: bool = True):
+    def validate_script(self, verbose: bool = True):
         # TODO: script has to not contain priority == -inf, because it uses for miss values
-        flow_labels = []
-        node_labels = []
-        labels = []
-        conditions = []
+        error_msgs = []
         for flow_name, flow in self.script.items():
             for node_name, node in flow.items():
-                flow_labels += [flow_name] * len(node.transitions)
-                node_labels += [node_name] * len(node.transitions)
-                labels += list(node.transitions.keys())
-                conditions += list(node.transitions.values())
-
-        error_msgs = []
-        for flow_label, node_label, label, condition in zip(flow_labels, node_labels, labels, conditions):
-            ctx = Context()
-            ctx.validation = True
-            ctx.add_request(Message(text="text"))
-
-            label = label(ctx, pipeline) if callable(label) else normalize_label(label, flow_label)
-
-            # validate labeling
-            try:
-                node = self.script[label[0]][label[1]]
-            except Exception as exc:
-                msg = (
-                    f"Could not find node with label={label}, "
-                    f"error was found in (flow_label, node_label)={(flow_label, node_label)}"
-                )
-                error_handler(error_msgs, msg, exc, verbose)
-                break
-
-            # validate responsing
-            response_func = normalize_response(node.response)
-            try:
-                response_result = response_func(ctx, pipeline)
-                if not isinstance(response_result, Message):
+                # validate labeling
+                for label in node.transitions.keys():
+                    if callable(label):
+                        validate_callable(
+                            label, "label", flow_name, node_name, error_msgs, verbose, [Context, Pipeline, Any, Any]
+                        )
+                    else:
+                        norm_label = normalize_label(label, flow_name)
+                        if norm_label is None:
+                            msg = (
+                                f"Label can not be normalized for label={label}, "
+                                f"error was found in (flow_label, node_label)={(flow_name, node_name)}"
+                            )
+                            error_handler(error_msgs, msg, None, verbose)
+                            continue
+                        norm_flow_label, norm_node_label, _ = norm_label
+                        if norm_flow_label not in self.script.keys():
+                            msg = (
+                                f"Flow label {norm_flow_label} can not be found for label={label}, "
+                                f"error was found in (flow_label, node_label)={(flow_name, node_name)}"
+                            )
+                        elif norm_node_label not in self.script[norm_flow_label].keys():
+                            msg = (
+                                f"Node label {norm_node_label} can not be found for label={label}, "
+                                f"error was found in (flow_label, node_label)={(flow_name, node_name)}"
+                            )
+                        else:
+                            msg = None
+                        if msg is not None:
+                            error_handler(error_msgs, msg, None, verbose)
+
+                # validate responses
+                if callable(node.response):
+                    validate_callable(
+                        node.response,
+                        "response",
+                        flow_name,
+                        node_name,
+                        error_msgs,
+                        verbose,
+                        [Context, Pipeline, Any, Any],
+                        (Message,),
+                    )
+                elif node.response is not None and not issubclass(type(node.response), Message):
                     msg = (
-                        "Expected type of response_result is `Message`.\n"
-                        + f"Got type(response_result)={type(response_result)}"
-                        f" for label={label} , error was found in (flow_label, node_label)={(flow_label, node_label)}"
+                        f"Expected type of response is subclass of {Message}, "
+                        f"got type(response)={type(node.response)}, "
+                        f"error was found in (flow_label, node_label)={(flow_name, node_name)}"
                     )
                     error_handler(error_msgs, msg, None, verbose)
-                    continue
-            except Exception as exc:
-                msg = (
-                    f"Got exception '''{exc}''' during response execution "
-                    f"for label={label} and node.response={node.response}"
-                    f", error was found in (flow_label, node_label)={(flow_label, node_label)}"
-                )
-                error_handler(error_msgs, msg, exc, verbose)
-                continue
-
-            # validate conditioning
-            try:
-                condition_result = condition(ctx, pipeline)
-                if not isinstance(condition(ctx, pipeline), bool):
-                    raise Exception(f"Returned condition_result={condition_result}, but expected bool type")
-            except Exception as exc:
-                msg = f"Got exception '''{exc}''' during condition execution for label={label}"
-                error_handler(error_msgs, msg, exc, verbose)
-                continue
+
+                # validate conditions
+                for label, condition in node.transitions.items():
+                    if callable(condition):
+                        validate_callable(
+                            condition,
+                            "condition",
+                            flow_name,
+                            node_name,
+                            error_msgs,
+                            verbose,
+                            [Context, Pipeline, Any, Any],
+                            (bool,),
+                        )
+                    else:
+                        msg = (
+                            f"Expected type of condition for label={label} is {Callable}, "
+                            f"got type(condition)={type(condition)}, "
+                            f"error was found in (flow_label, node_label)={(flow_name, node_name)}"
+                        )
+                        error_handler(error_msgs, msg, None, verbose)
+
+                # validate pre_transitions- and pre_response_processing
+                for place, functions in zip(
+                    ("transitions", "response"), (node.pre_transitions_processing, node.pre_response_processing)
+                ):
+                    for name, function in functions.items():
+                        if callable(function):
+                            validate_callable(
+                                function,
+                                f"pre_{place}_processing {name}",
+                                flow_name,
+                                node_name,
+                                error_msgs,
+                                verbose,
+                                [Context, Pipeline, Any, Any],
+                                (Context,),
+                            )
+                        else:
+                            msg = (
+                                f"Expected type of pre_{place}_processing {name} is {Callable}, "
+                                f"got type(pre_{place}_processing)={type(function)}, "
+                                f"error was found in (flow_label, node_label)={(flow_name, node_name)}"
+                            )
+                            error_handler(error_msgs, msg, None, verbose)
         return error_msgs
 
 

dff/pipeline/pipeline/pipeline.py

@@ -51,8 +51,6 @@ class Pipeline:
     :param fallback_label: Actor fallback label.
     :param label_priority: Default priority value for all actor :py:const:`labels <dff.script.NodeLabel3Type>`
         where there is no priority. Defaults to `1.0`.
-    :param validation_stage: This flag sets whether the validation stage is executed after actor creation.
-        It is executed by default. Defaults to `None`.
     :param condition_handler: Handler that processes a call of actor condition functions. Defaults to `None`.
     :param verbose: If it is `True`, logging is used in actor. Defaults to `True`.
     :param handlers: This variable is responsible for the usage of external handlers on
@@ -84,7 +82,6 @@ def __init__(
         start_label: NodeLabel2Type,
         fallback_label: Optional[NodeLabel2Type] = None,
         label_priority: float = 1.0,
-        validation_stage: Optional[bool] = None,
         condition_handler: Optional[Callable] = None,
         verbose: bool = True,
         handlers: Optional[Dict[ActorStage, List[Callable]]] = None,
@@ -116,7 +113,6 @@ def __init__(
                 start_label,
                 fallback_label,
                 label_priority,
-                validation_stage,
                 condition_handler,
                 verbose,
                 handlers,
@@ -204,7 +200,6 @@ def from_script(
         start_label: NodeLabel2Type,
         fallback_label: Optional[NodeLabel2Type] = None,
         label_priority: float = 1.0,
-        validation_stage: Optional[bool] = None,
         condition_handler: Optional[Callable] = None,
         verbose: bool = True,
         handlers: Optional[Dict[ActorStage, List[Callable]]] = None,
@@ -226,8 +221,6 @@ def from_script(
         :param fallback_label: Actor fallback label.
         :param label_priority: Default priority value for all actor :py:const:`labels <dff.script.NodeLabel3Type>`
             where there is no priority. Defaults to `1.0`.
-        :param validation_stage: This flag sets whether the validation stage is executed after actor creation.
-            It is executed by default. Defaults to `None`.
         :param condition_handler: Handler that processes a call of actor condition functions. Defaults to `None`.
         :param verbose: If it is `True`, logging is used in actor. Defaults to `True`.
         :param handlers: This variable is responsible for the usage of external handlers on
@@ -254,7 +247,6 @@ def from_script(
             start_label=start_label,
             fallback_label=fallback_label,
             label_priority=label_priority,
-            validation_stage=validation_stage,
             condition_handler=condition_handler,
             verbose=verbose,
             handlers=handlers,
@@ -269,7 +261,6 @@ def set_actor(
         start_label: NodeLabel2Type,
         fallback_label: Optional[NodeLabel2Type] = None,
         label_priority: float = 1.0,
-        validation_stage: Optional[bool] = None,
         condition_handler: Optional[Callable] = None,
         verbose: bool = True,
         handlers: Optional[Dict[ActorStage, List[Callable]]] = None,
@@ -286,8 +277,6 @@ def set_actor(
             or there was an error while executing the scenario.
         :param label_priority: Default priority value for all actor :py:const:`labels <dff.script.NodeLabel3Type>`
             where there is no priority. Defaults to `1.0`.
-        :param validation_stage: This flag sets whether the validation stage is executed in actor.
-            It is executed by default. Defaults to `None`.
         :param condition_handler: Handler that processes a call of actor condition functions. Defaults to `None`.
         :param verbose: If it is `True`, logging is used in actor. Defaults to `True`.
         :param handlers: This variable is responsible for the usage of external handlers on
@@ -298,7 +287,7 @@ def set_actor(
         """
         old_actor = self.actor
         self.actor = Actor(script, start_label, fallback_label, label_priority, condition_handler, handlers)
-        errors = self.actor.validate_script(self, verbose) if validation_stage is not False else []
+        errors = self.actor.validate_script(verbose)
         if errors:
             self.actor = old_actor
             raise ValueError(

dff/pipeline/types.py

@@ -238,7 +238,6 @@ class ExtraHandlerRuntimeInfo(BaseModel):
         "start_label": NodeLabel2Type,
         "fallback_label": NotRequired[Optional[NodeLabel2Type]],
         "label_priority": NotRequired[float],
-        "validation_stage": NotRequired[Optional[bool]],
         "condition_handler": NotRequired[Optional[Callable]],
         "verbose": NotRequired[bool],
         "handlers": NotRequired[Optional[Dict[ActorStage, List[Callable]]]],

dff/script/core/context.py

@@ -85,14 +85,6 @@ class Context(BaseModel):
         - key - Arbitrary data name.
         - value - Arbitrary data.
     """
-    validation: bool = False
-    """
-    `validation` is a flag that signals that :py:class:`~dff.pipeline.pipeline.pipeline.Pipeline`,
-    while being initialized, checks the :py:class:`~dff.script.core.script.Script`.
-    The functions that can give not valid data
-    while being validated must use this flag to take the validation mode into account.
-    Otherwise the validation will not be passed.
-    """
     framework_states: Dict[ModuleName, Dict[str, Any]] = {}
     """
     `framework_states` is used for addons states or for