Actor revalidation

dff/messengers/telegram/messenger.py

@@ -232,7 +232,7 @@ def telegram_condition(
         **kwargs,
     )
 
-    def condition(ctx: Context, _: Pipeline, *__, **___):  # pragma: no cover
+    def condition(ctx: Context, _: Pipeline) -> bool:  # pragma: no cover
         last_request = ctx.last_request
         if last_request is None:
             return False

dff/pipeline/pipeline/actor.py

@@ -45,22 +45,6 @@
     from dff.pipeline.pipeline.pipeline import Pipeline
 
 
-def error_handler(error_msgs: list, msg: str, exception: Optional[Exception] = None, logging_flag: bool = True):
-    """
-    This function handles errors during :py:class:`~dff.script.Script` validation.
-
-    :param error_msgs: List that contains error messages. :py:func:`~dff.script.error_handler`
-        adds every next error message to that list.
-    :param msg: Error message which is to be added into `error_msgs`.
-    :param exception: Invoked exception. If it has been set, it is used to obtain logging traceback.
-        Defaults to `None`.
-    :param logging_flag: The flag which defines whether logging is necessary. Defaults to `True`.
-    """
-    error_msgs.append(msg)
-    if logging_flag:
-        logger.error(msg, exc_info=exception)
-
-
 class Actor:
     """
     The class which is used to process :py:class:`~dff.script.Context`
@@ -92,11 +76,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}")
@@ -389,36 +373,6 @@ def _choose_label(
             chosen_label = self.fallback_label
         return chosen_label
 
-    def validate_script(self, pipeline: Pipeline, verbose: bool = True):
-        # TODO: script has to not contain priority == -inf, because it uses for miss values
-        flow_labels = []
-        node_labels = []
-        labels = []
-        conditions = []
-        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):
-            if not callable(label):
-                label = 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
-        return error_msgs
-
 
 async def default_condition_handler(
     condition: Callable, ctx: Context, pipeline: Pipeline

dff/pipeline/pipeline/pipeline.py

@@ -52,8 +52,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
@@ -88,7 +86,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,
@@ -121,7 +118,6 @@ def __init__(
                 start_label,
                 fallback_label,
                 label_priority,
-                validation_stage,
                 condition_handler,
                 verbose,
                 handlers,
@@ -211,7 +207,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,
         parallelize_processing: bool = False,
@@ -234,8 +229,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 parallelize_processing: This flag determines whether or not the functions
@@ -265,7 +258,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,
             parallelize_processing=parallelize_processing,
@@ -281,7 +273,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,
@@ -298,8 +289,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
@@ -308,14 +297,7 @@ def set_actor(
             - key :py:class:`~dff.script.ActorStage` - Stage in which the handler is called.
             - value List[Callable] - The list of called handlers for each stage. Defaults to an empty `dict`.
         """
-        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 []
-        if errors:
-            self.actor = old_actor
-            raise ValueError(
-                f"Found {len(errors)} errors: " + " ".join([f"{i}) {er}" for i, er in enumerate(errors, 1)])
-            )
 
     @classmethod
     def from_dict(cls, dictionary: PipelineBuilder) -> "Pipeline":

dff/pipeline/types.py

@@ -263,7 +263,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

@@ -88,14 +88,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
@@ -142,7 +134,7 @@ def cast(cls, ctx: Optional[Union[Context, dict, str]] = None, *args, **kwargs)
             ctx = Context.model_validate(ctx)
         elif isinstance(ctx, str):
             ctx = Context.model_validate_json(ctx)
-        elif not issubclass(type(ctx), Context):
+        elif not isinstance(ctx, Context):
             raise ValueError(
                 f"Context expected to be an instance of the Context class "
                 f"or an instance of the dict/str(json) type. Got: {type(ctx)}"

dff/script/core/normalization.py

@@ -31,8 +31,7 @@ def normalize_label(
     :param label: If label is Callable the function is wrapped into try/except
         and normalization is used on the result of the function call with the name label.
     :param default_flow_label: flow_label is used if label does not contain flow_label.
-    :return: Result of the label normalization,
-        if Callable is returned, the normalized result is returned.
+    :return: Result of the label normalization
     """
     if callable(label):
 
@@ -62,6 +61,10 @@ def get_label_handler(ctx: Context, pipeline: Pipeline) -> NodeLabel3Type:
     elif isinstance(label, tuple) and len(label) == 3:
         flow_label = label[0] or default_flow_label
         return (flow_label, label[1], label[2])
+    else:
+        raise TypeError(
+            f"Label '{label!r}' is of incorrect type. It has to follow the `NodeLabelType`:\n" f"{NodeLabelType!r}"
+        )
 
 
 def normalize_condition(condition: ConditionType) -> Callable[[Context, Pipeline], bool]: