Pydantic improvements

chatsky/__rebuild_pydantic_models__.py

@@ -1,11 +1,9 @@
 # flake8: noqa: F401
 
 from chatsky.pipeline import Pipeline
-from chatsky.pipeline.pipeline.component import PipelineComponent
 from chatsky.pipeline.types import ExtraHandlerRuntimeInfo, StartConditionCheckerFunction
 from chatsky.script import Context, Script
 
-PipelineComponent.model_rebuild()
 Pipeline.model_rebuild()
 Script.model_rebuild()
 Context.model_rebuild()

chatsky/pipeline/__init__.py

@@ -22,9 +22,9 @@
     ServiceFunction,
 )
 
-from .pipeline.pipeline import Pipeline
-from .pipeline.actor import Actor
-
 from .service.extra import BeforeHandler, AfterHandler, ComponentExtraHandler
-from .service.group import ServiceGroup
 from .service.service import Service, to_service
+from .service.group import ServiceGroup
+
+from .pipeline.actor import Actor
+from .pipeline.pipeline import Pipeline

chatsky/pipeline/pipeline/actor.py

@@ -62,60 +62,76 @@ async def default_condition_handler(
     return await wrap_sync_function_in_async(condition, ctx, pipeline)
 
 
-class Actor(PipelineComponent, extra="forbid", arbitrary_types_allowed=True):
+class Actor(PipelineComponent):
     """
     The class which is used to process :py:class:`~chatsky.script.Context`
     according to the :py:class:`~chatsky.script.Script`.
-
-    :param script: The dialog scenario: a graph described by the :py:class:`.Keywords`.
-        While the graph is being initialized, it is validated and then used for the dialog.
-    :param start_label: The start node of :py:class:`~chatsky.script.Script`. The execution begins with it.
-    :param fallback_label: The label of :py:class:`~chatsky.script.Script`.
-        Dialog comes into that label if all other transitions failed,
-        or there was an error while executing the scenario.
-        Defaults to `None`.
-    :param label_priority: Default priority value for all :py:const:`labels <chatsky.script.ConstLabel>`
-        where there is no priority. Defaults to `1.0`.
-    :param condition_handler: Handler that processes a call of condition functions. Defaults to `None`.
-    :param handlers: This variable is responsible for the usage of external handlers on
-        the certain stages of work of :py:class:`~chatsky.script.Actor`.
-
-        - key (:py:class:`~chatsky.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`.
     """
 
-    script: Union[Script, dict]
+    script: Union[Script, Dict]
+    """
+    The dialog scenario: a graph described by the :py:class:`.Keywords`.
+    While the graph is being initialized, it is validated and then used for the dialog.
+    """
     start_label: NodeLabel2Type
+    """
+    The start node of :py:class:`~chatsky.script.Script`. The execution begins with it.
+    """
     fallback_label: Optional[NodeLabel2Type] = None
+    """
+    The label of :py:class:`~chatsky.script.Script`.
+    Dialog comes into that label if all other transitions failed,
+    or there was an error while executing the scenario. Defaults to `None`.
+    """
     label_priority: float = 1.0
+    """
+    Default priority value for all :py:const:`labels <chatsky.script.ConstLabel>`
+    where there is no priority. Defaults to `1.0`.
+    """
     condition_handler: Callable = Field(default=default_condition_handler)
+    """
+    Handler that processes a call of condition functions. Defaults to `None`.
+    """
     handlers: Dict[ActorStage, List[Callable]] = Field(default_factory=dict)
-    _clean_turn_cache: Optional[bool] = True
+    """
+    This variable is responsible for the usage of external handlers on
+    the certain stages of work of :py:class:`~chatsky.script.Actor`.
+
+    - key (:py:class:`~chatsky.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`.
+
+    """
+    # NB! The following API is highly experimental and may be removed at ANY time WITHOUT FURTHER NOTICE!!
+    _clean_turn_cache: bool = True
 
     @model_validator(mode="after")
-    def tick_async_flag(self):
+    def __tick_async_flag__(self):
         self.calculated_async_flag = False
         return self
 
     @model_validator(mode="after")
-    def actor_validator(self):
+    def __start_label_validator__(self):
         if not isinstance(self.script, Script):
             self.script = Script(script=self.script)
         self.start_label = normalize_label(self.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}")
+        return self
 
+    @model_validator(mode="after")
+    def __fallback_label_validator__(self):
         if self.fallback_label is None:
             self.fallback_label = self.start_label
         else:
             self.fallback_label = normalize_label(self.fallback_label)
             if self.script.get(self.fallback_label[0], {}).get(self.fallback_label[1]) is None:
                 raise ValueError(f"Unknown fallback_label={self.fallback_label}")
-
-        # NB! The following API is highly experimental and may be removed at ANY time WITHOUT FURTHER NOTICE!!
-        self._clean_turn_cache = True
         return self
 
+    @property
+    def computed_name(self) -> str:
+        return "actor"
+
     async def run_component(self, ctx: Context, pipeline: Pipeline) -> None:
         """
         Method for running an `Actor`.

chatsky/pipeline/pipeline/component.py

@@ -40,40 +40,56 @@ class PipelineComponent(abc.ABC, BaseModel, extra="forbid", arbitrary_types_allo
     """
     This class represents a pipeline component, which is a service or a service group.
     It contains some fields that they have in common.
-
-    :param before_handler: :py:class:`~.BeforeHandler`, associated with this component.
-    :type before_handler: Optional[:py:data:`~.ComponentExtraHandler`]
-    :param after_handler: :py:class:`~.AfterHandler`, associated with this component.
-    :type after_handler: Optional[:py:data:`~.ComponentExtraHandler`]
-    :param timeout: (for asynchronous only!) Maximum component execution time (in seconds),
-        if it exceeds this time, it is interrupted.
-    :param requested_async_flag: Requested asynchronous property;
-        if not defined, `calculated_async_flag` is used instead.
-    :param calculated_async_flag: Whether the component can be asynchronous or not
-        1) for :py:class:`~.pipeline.service.service.Service`: whether its `handler` is asynchronous or not,
-        2) for :py:class:`~.pipeline.service.group.ServiceGroup`: whether all its `services` are asynchronous or not.
-
-    :param start_condition: StartConditionCheckerFunction that is invoked before each component execution;
-        component is executed only if it returns `True`.
-    :type start_condition: Optional[:py:data:`~.StartConditionCheckerFunction`]
-    :param name: Component name (should be unique in single :py:class:`~.pipeline.service.group.ServiceGroup`),
-        should not be blank or contain `.` symbol.
-    :param path: Separated by dots path to component, is universally unique.
     """
 
     before_handler: BeforeHandler = Field(default_factory=BeforeHandler)
+    """
+    :py:class:`~.BeforeHandler`, associated with this component.
+    """
     after_handler: AfterHandler = Field(default_factory=AfterHandler)
+    """
+    :py:class:`~.AfterHandler`, associated with this component.
+    """
     timeout: Optional[float] = None
+    """
+    (for asynchronous only!) Maximum component execution time (in seconds),
+    if it exceeds this time, it is interrupted.
+    """
     requested_async_flag: Optional[bool] = None
+    """
+    Requested asynchronous property; if not defined,
+    `calculated_async_flag` is used instead.
+    """
     calculated_async_flag: bool = False
+    """
+    Whether the component can be asynchronous or not.
+
+    1) for :py:class:`~.pipeline.service.service.Service`: whether its `handler` is asynchronous or not,
+    2) for :py:class:`~.pipeline.service.group.ServiceGroup`: whether all its `services` are asynchronous or not.
+
+    """
     start_condition: StartConditionCheckerFunction = Field(default=always_start_condition)
+    """
+    StartConditionCheckerFunction that is invoked before each component execution;
+    component is executed only if it returns `True`.
+    """
     name: Optional[str] = None
+    """
+    Component name (should be unique in single :py:class:`~.pipeline.service.group.ServiceGroup`),
+    should not be blank or contain `.` symbol.
+    """
     path: Optional[str] = None
+    """
+    Separated by dots path to component, is universally unique.
+    """
 
     @model_validator(mode="after")
-    def pipeline_component_validator(self):
-        if self.name is not None and (self.name == "" or "." in self.name):
-            raise Exception(f"User defined service name shouldn't be blank or contain '.' (service: {self.name})!")
+    def __pipeline_component_validator(self):
+        if self.name is not None:
+            if self.name == "":
+                raise ValueError("Name cannot be blank.")
+            if "." in self.name:
+                raise ValueError(f"Name cannot contain '.': {self.name!r}.")
 
         if not self.calculated_async_flag and self.requested_async_flag:
             raise Exception(f"{type(self).__name__} '{self.name}' can't be asynchronous!")
@@ -134,9 +150,35 @@ async def run_extra_handler(self, stage: ExtraHandlerType, ctx: Context, pipelin
             logger.warning(f"{type(self).__name__} '{self.name}' {extra_handler.stage} extra handler timed out!")
 
     @abc.abstractmethod
-    async def run_component(self, ctx: Context, pipeline: Pipeline) -> None:
+    async def run_component(self, ctx: Context, pipeline: Pipeline) -> Optional[ComponentExecutionState]:
+        """
+        Method for running this component. It can be an Actor, Service or ServiceGroup.
+        It has to be defined in the child classes,
+        which is done in each of the default PipelineComponents.
+        Service 'handler' has three possible signatures. These possible signatures are:
+
+        - (ctx: Context) - accepts current dialog context only.
+        - (ctx: Context, pipeline: Pipeline) - accepts context and current pipeline.
+        - | (ctx: Context, pipeline: Pipeline, info: ServiceRuntimeInfo) - accepts context,
+              pipeline and service runtime info dictionary.
+
+        :param ctx: Current dialog context.
+        :param pipeline: The current pipeline.
+        :return: `None`
+        """
         raise NotImplementedError
 
+    @property
+    def computed_name(self) -> str:
+        """
+        Every derivative of `PipelineComponent` must define this property.
+        :return: `str`.
+        """
+        return "noname_service"
+        # Or could do the following:
+        # raise NotImplementedError
+        # But this default value makes sense and replicates previous logic.
+
     async def _run(self, ctx: Context, pipeline: Pipeline) -> None:
         """
         A method for running a pipeline component. Executes extra handlers before and after execution,
@@ -145,21 +187,20 @@ async def _run(self, ctx: Context, pipeline: Pipeline) -> None:
         :param ctx: Current dialog :py:class:`~.Context`.
         :param pipeline: This :py:class:`~.Pipeline`.
         """
-        if await wrap_sync_function_in_async(self.start_condition, ctx, pipeline):
-            try:
+        try:
+            if await wrap_sync_function_in_async(self.start_condition, ctx, pipeline):
                 await self.run_extra_handler(ExtraHandlerType.BEFORE, ctx, pipeline)
 
                 self._set_state(ctx, ComponentExecutionState.RUNNING)
-                await self.run_component(ctx, pipeline)
-                if self.get_state(ctx) is not ComponentExecutionState.FAILED:
+                if await self.run_component(ctx, pipeline) is not ComponentExecutionState.FAILED:
                     self._set_state(ctx, ComponentExecutionState.FINISHED)
 
                 await self.run_extra_handler(ExtraHandlerType.AFTER, ctx, pipeline)
-            except Exception as exc:
-                self._set_state(ctx, ComponentExecutionState.FAILED)
-                logger.error(f"Service '{self.name}' execution failed!", exc_info=exc)
-        else:
-            self._set_state(ctx, ComponentExecutionState.NOT_RUN)
+            else:
+                self._set_state(ctx, ComponentExecutionState.NOT_RUN)
+        except Exception as exc:
+            self._set_state(ctx, ComponentExecutionState.FAILED)
+            logger.error(f"Service '{self.name}' execution failed!", exc_info=exc)
 
     async def __call__(self, ctx: Context, pipeline: Pipeline) -> Optional[Awaitable]:
         """