rasa-pro 3.9.18__py3-none-any.whl

rasa/shared/core/training_data/loading.py

@@ -0,0 +1,89 @@
+import logging
+import os
+from typing import Text, Optional, List, Union
+
+import rasa.shared.data
+import rasa.shared.utils.io
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.training_data.story_reader.story_reader import StoryReader
+from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
+    YAMLStoryReader,
+)
+from rasa.shared.core.training_data.structures import StoryStep
+from rasa.shared.data import YAML_FILE_EXTENSIONS
+
+logger = logging.getLogger(__name__)
+
+
+def _get_reader(filename: Text, domain: Domain) -> StoryReader:
+    if rasa.shared.data.is_likely_yaml_file(filename):
+        return YAMLStoryReader(domain, filename)
+    else:
+        # This is a use case for uploading the story over REST API.
+        # The source file has a random name.
+        return _guess_reader(filename, domain)
+
+
+def _guess_reader(filename: Text, domain: Domain) -> StoryReader:
+    if YAMLStoryReader.is_stories_file(filename):
+        return YAMLStoryReader(domain, filename)
+
+    raise ValueError(
+        f"Failed to find a reader class for the story file `{filename}`. "
+        f"Supported formats are "
+        f"{', '.join(YAML_FILE_EXTENSIONS)}."
+    )
+
+
+def load_data_from_resource(
+    resource: Union[Text], domain: Domain, exclusion_percentage: Optional[int] = None
+) -> List["StoryStep"]:
+    """Loads core training data from the specified folder.
+
+    Args:
+        resource: Folder/File with core training data files.
+        domain: Domain object.
+        exclusion_percentage: Identifies the percentage of training data that
+                              should be excluded from the training.
+
+    Returns:
+        Story steps from the training data.
+    """
+    if not os.path.exists(resource):
+        raise ValueError(f"Resource '{resource}' does not exist.")
+
+    return load_data_from_files(
+        rasa.shared.utils.io.list_files(resource), domain, exclusion_percentage
+    )
+
+
+def load_data_from_files(
+    story_files: List[Text], domain: Domain, exclusion_percentage: Optional[int] = None
+) -> List["StoryStep"]:
+    """Loads core training data from the specified files.
+
+    Args:
+        story_files: List of files with training data in it.
+        domain: Domain object.
+        exclusion_percentage: Identifies the percentage of training data that
+                              should be excluded from the training.
+
+    Returns:
+        Story steps from the training data.
+    """
+    story_steps = []
+
+    for story_file in story_files:
+        reader = _get_reader(story_file, domain)
+
+        steps = reader.read_from_file(story_file)
+        story_steps.extend(steps)
+
+    if exclusion_percentage and exclusion_percentage != 100:
+        import random
+
+        idx = int(round(exclusion_percentage / 100.0 * len(story_steps)))
+        random.shuffle(story_steps)
+        story_steps = story_steps[:-idx]
+
+    return story_steps

rasa/shared/core/training_data/story_reader/story_reader.py

@@ -0,0 +1,129 @@
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Text, List, Any, Union
+
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import SlotSet, ActionExecuted, Event
+from rasa.shared.exceptions import RasaCoreException
+from rasa.shared.core.training_data.story_reader.story_step_builder import (
+    StoryStepBuilder,
+)
+from rasa.shared.core.training_data.structures import StoryStep
+
+logger = logging.getLogger(__name__)
+
+
+class StoryReader:
+    """Helper class to read a story file."""
+
+    def __init__(
+        self, domain: Optional[Domain] = None, source_name: Optional[Text] = None
+    ) -> None:
+        """Constructor for the StoryReader.
+
+        Args:
+            domain: Domain object.
+            source_name: Name of the training data source.
+        """
+        self.story_steps: List[StoryStep] = []
+        self.current_step_builder: Optional[StoryStepBuilder] = None
+        self.domain = domain
+        self.source_name = source_name
+        self._is_parsing_conditions = False
+
+    def read_from_file(
+        self, filename: Text, skip_validation: bool = False
+    ) -> List[StoryStep]:
+        """Reads stories or rules from file.
+
+        Args:
+            filename: Path to the story/rule file.
+            skip_validation: `True` if file validation should be skipped.
+
+        Returns:
+            `StoryStep`s read from `filename`.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def is_stories_file(filename: Union[Text, Path]) -> bool:
+        """Checks if the specified file is a story file.
+
+        Args:
+            filename: File to check.
+
+        Returns:
+            `True` if specified file is a story file, `False` otherwise.
+        """
+        raise NotImplementedError
+
+    def _add_current_stories_to_result(self) -> None:
+        if self.current_step_builder:
+            self.current_step_builder.flush()
+            self.story_steps.extend(self.current_step_builder.story_steps)
+
+    def _new_story_part(self, name: Text, source_name: Optional[Text]) -> None:
+        self._add_current_stories_to_result()
+        self.current_step_builder = StoryStepBuilder(name, source_name)
+
+    def _new_rule_part(self, name: Text, source_name: Optional[Text]) -> None:
+        self._add_current_stories_to_result()
+        self.current_step_builder = StoryStepBuilder(name, source_name, is_rule=True)
+
+    def _parse_events(
+        self, event_name: Text, parameters: Dict[Text, Any]
+    ) -> Optional[List["Event"]]:
+        # add 'name' only if event is not a SlotSet,
+        # because there might be a slot with slot_key='name'
+        if "name" not in parameters and event_name != SlotSet.type_name:
+            parameters["name"] = event_name
+
+        parsed_events = Event.from_story_string(
+            event_name, parameters, default=ActionExecuted
+        )
+        if parsed_events is None:
+            raise StoryParseError(
+                "Unknown event '{}'. It is Neither an event nor an action).".format(
+                    event_name
+                )
+            )
+
+        return parsed_events
+
+    def _add_event(self, event_name: Text, parameters: Dict[Text, Any]) -> None:
+        parsed_events = self._parse_events(event_name, parameters)
+        if parsed_events is None:
+            parsed_events = []
+
+        if self.current_step_builder is None:
+            raise StoryParseError(
+                "Failed to handle event '{}'. There is no "
+                "started story block available. "
+                "".format(event_name)
+            )
+
+        for p in parsed_events:
+            if self._is_parsing_conditions:
+                self.current_step_builder.add_event_as_condition(p)
+            else:
+                self.current_step_builder.add_event(p)
+
+    def _add_checkpoint(
+        self, name: Text, conditions: Optional[Dict[Text, Any]]
+    ) -> None:
+        # Ensure story part already has a name
+        if not self.current_step_builder:
+            raise StoryParseError(
+                "Checkpoint '{}' is at an invalid location. "
+                "Expected a story start.".format(name)
+            )
+
+        self.current_step_builder.add_checkpoint(name, conditions)
+
+
+class StoryParseError(RasaCoreException, ValueError):
+    """Raised if there is an error while parsing a story file."""
+
+    def __init__(self, message: Text) -> None:
+        self.message = message
+        super(StoryParseError, self).__init__()

rasa/shared/core/training_data/story_reader/story_step_builder.py

@@ -0,0 +1,168 @@
+import logging
+from typing import Text, Optional, Dict, Any, List
+
+import rasa.shared.core.training_data.structures
+import rasa.shared.utils.io
+from rasa.shared.constants import DOCS_URL_STORIES
+from rasa.shared.core.events import UserUttered, Event
+from rasa.shared.core.training_data.structures import (
+    Checkpoint,
+    GENERATED_CHECKPOINT_PREFIX,
+    GENERATED_HASH_LENGTH,
+    STORY_START,
+    StoryStep,
+    RuleStep,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StoryStepBuilder:
+    def __init__(
+        self, name: Text, source_name: Optional[Text], is_rule: bool = False
+    ) -> None:
+        self.name = name
+        self.source_name = source_name
+        self.story_steps: List[StoryStep] = []
+        self.current_steps: List[StoryStep] = []
+        self.start_checkpoints: List[Checkpoint] = []
+        self.is_rule = is_rule
+
+    def add_checkpoint(self, name: Text, conditions: Optional[Dict[Text, Any]]) -> None:
+        """Add a checkpoint to story steps."""
+        # Depending on the state of the story part this
+        # is either a start or an end check point
+        if not self.current_steps:
+            self.start_checkpoints.append(Checkpoint(name, conditions))
+        else:
+            if conditions:
+                rasa.shared.utils.io.raise_warning(
+                    f"End or intermediate checkpoints "
+                    f"do not support conditions! "
+                    f"(checkpoint: {name})",
+                    docs=DOCS_URL_STORIES + "#checkpoints",
+                )
+            additional_steps = []
+            for t in self.current_steps:
+                if t.end_checkpoints:
+                    tcp = t.create_copy(use_new_id=True)
+                    tcp.end_checkpoints = [Checkpoint(name)]
+                    additional_steps.append(tcp)
+                else:
+                    t.end_checkpoints = [Checkpoint(name)]
+            self.current_steps.extend(additional_steps)
+
+    def _prev_end_checkpoints(self) -> List[Checkpoint]:
+        if not self.current_steps:
+            return self.start_checkpoints
+        else:
+            # makes sure we got each end name only once
+            end_names = {e.name for s in self.current_steps for e in s.end_checkpoints}
+            return [Checkpoint(name) for name in end_names]
+
+    def add_user_messages(self, messages: List[UserUttered]) -> None:
+        """Adds next story steps with the user's utterances.
+
+        Args:
+            messages: User utterances.
+        """
+        self.add_events(messages)
+
+    def add_events(self, events: List[Event]) -> None:
+        """Adds next story steps with the specified list of events.
+
+        Args:
+            events: Events that need to be added.
+        """
+        self.ensure_current_steps()
+
+        if len(events) == 1:
+            # If there is only one possible event, we'll keep things simple
+            for t in self.current_steps:
+                t.add_event(events[0])
+        else:
+            # If there are multiple different events the
+            # user can use the express the same thing
+            # we need to copy the blocks and create one
+            # copy for each possible message
+            generated_checkpoint = self._generate_checkpoint_name_for_or_statement(
+                events
+            )
+            updated_steps = []
+            for t in self.current_steps:
+                for event in events:
+                    copied = t.create_copy(use_new_id=True)
+                    copied.add_event(event)
+                    copied.end_checkpoints = [Checkpoint(generated_checkpoint)]
+                    updated_steps.append(copied)
+            self.current_steps = updated_steps
+
+    def add_event_as_condition(self, event: Event) -> None:
+        self.add_event(event, True)
+
+    def add_event(self, event: Event, is_condition: bool = False) -> None:
+        self.ensure_current_steps()
+        for t in self.current_steps:
+            # conditions are supported only for the RuleSteps
+            if isinstance(t, RuleStep) and is_condition:
+                t.add_event_as_condition(event)
+            else:
+                t.add_event(event)
+
+    def ensure_current_steps(self) -> None:
+        completed = [step for step in self.current_steps if step.end_checkpoints]
+        unfinished = [step for step in self.current_steps if not step.end_checkpoints]
+        self.story_steps.extend(completed)
+        if unfinished:
+            self.current_steps = unfinished
+        else:
+            self.current_steps = self._next_story_steps()
+
+    def flush(self) -> None:
+        if self.current_steps:
+            self.story_steps.extend(self.current_steps)
+            self.current_steps = []
+
+    def _next_story_steps(self) -> List[StoryStep]:
+        start_checkpoints = self._prev_end_checkpoints()
+        if not start_checkpoints:
+            start_checkpoints = [Checkpoint(STORY_START)]
+        step_class = RuleStep if self.is_rule else StoryStep
+        current_turns = [
+            step_class(
+                block_name=self.name,
+                start_checkpoints=start_checkpoints,
+                source_name=self.source_name,
+            )
+        ]
+        return current_turns
+
+    def _generate_checkpoint_name_for_or_statement(self, events: List[Event]) -> str:
+        """Generates a unique checkpoint name for an or statement.
+
+        The name is based on the current story/rule name,
+        the current place in the story since the last checkpoint or start,
+        the name of the starting checkpoints,
+        and the involved intents/e2e messages.
+        """
+        sorted_events = sorted([str(m) for m in events])
+        start_checkpoint_names = sorted(
+            list({chk.name for s in self.current_steps for chk in s.start_checkpoints})
+        )
+        event_names = [str(e) for s in self.current_steps for e in s.events]
+        # name: to identify the current story or rule
+        # events: to identify what has happened so far
+        #         within the current story/rule
+        # start checkpoint names: to identify the section
+        #                         within the current story/rule when there are
+        #                         multiple internal checkpoints
+        # messages texts or intents: identifying the members of the or statement
+        unique_id = (
+            f"{self.name}_<>_{'@@@'.join(event_names)}"
+            f"_<>_{'@@@'.join(start_checkpoint_names)}"
+            f"_<>_{'@@@'.join(sorted_events)}"
+        )
+        hashed_id = rasa.shared.utils.io.get_text_hash(unique_id)[
+            :GENERATED_HASH_LENGTH
+        ]
+        return f"{GENERATED_CHECKPOINT_PREFIX}OR_{hashed_id}"