rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/core/channels/inspector/src/helpers/formatters.test.ts

@@ -0,0 +1,392 @@
+import { Event } from "../types";
+import {
+  formatSlots,
+  formatTestCases,
+  formatFlow,
+  parseFieldUsingStack,
+} from "./formatters";
+
+describe("helpers", () => {
+  describe("formatSlots", () => {
+    test("should return an empty array if no slots are provided", () => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = formatSlots(undefined);
+      expect(result).toEqual([]);
+    });
+
+    test("should filter out slots with no value", () => {
+      const slots = {
+        slot1: null,
+        slot2: null,
+      };
+      const result = formatSlots(slots);
+      expect(result).toEqual([]);
+    });
+
+    test("should filter out `dialogue_stack` slots", () => {
+      const slots = {
+        dialogue_stack: "anything",
+      };
+      const result = formatSlots(slots);
+      expect(result).toEqual([]);
+    });
+
+    test("should filter out `flow_hashes` slots", () => {
+      const slots = {
+        flow_hashes: "anything",
+      };
+      const result = formatSlots(slots);
+      expect(result).toEqual([]);
+    });
+
+    test("should format a list of slots", () => {
+      const slots = {
+        slot1: true,
+        slot2: "value",
+      };
+      const result = formatSlots(slots);
+      expect(result).toEqual([
+        {
+          name: "slot1",
+          value: true,
+        },
+        {
+          name: "slot2",
+          value: "value",
+        },
+      ]);
+    });
+  });
+
+  describe("formatTestCases", () => {
+    const sessionId = "session-id";
+
+    test("should format an empty list of events", () => {
+      const events: Event[] = [];
+      const result = formatTestCases(events, sessionId);
+      expect(result).toEqual(`test_cases:
+  - test_case: ${sessionId}
+    steps: []`);
+    });
+
+    test("should format a list of events", () => {
+      const events: Event[] = [
+        {
+          event: "user",
+          text: "book a restaurant",
+          timestamp: "123",
+        },
+        {
+          event: "bot",
+          metadata: {
+            utter_action: "utter_ask_book_restaurant_name_of_restaurant",
+          },
+          text: "What's the name of the restaurant you are interested in?",
+          timestamp: "124",
+        },
+        {
+          event: "user",
+          text: "simsim",
+          timestamp: "125",
+        },
+        {
+          event: "bot",
+          text: "How many people are we talking?",
+          timestamp: "126",
+        },
+        {
+          event: "user",
+          text: "100",
+          timestamp: "127",
+        },
+        {
+          event: "bot",
+          metadata: {
+            utter_action: "utter_ask_book_restaurant_date",
+          },
+          text: "For which day do you want to book?",
+          timestamp: "128",
+        },
+      ];
+      const result = formatTestCases(events, sessionId);
+
+      expect(result).toEqual(`test_cases:
+  - test_case: ${sessionId}
+    steps:
+    - user: "book a restaurant"
+    - utter: utter_ask_book_restaurant_name_of_restaurant
+    - user: "simsim"
+    - bot: "How many people are we talking?"
+    - user: "100"
+    - utter: utter_ask_book_restaurant_date`);
+    });
+  });
+
+  describe("formatFlow", () => {
+    test("should render a step sequence", () => {
+      const slots = [
+        {
+          name: "book_restaurant_offered_alternative_dates",
+          value: [],
+        },
+        {
+          name: "book_restaurant_is_date_flexible",
+          value: true,
+        },
+        {
+          name: "book_restaurant_name_of_restaurant",
+          value: "fonfon",
+        },
+        {
+          name: "book_restaurant_number_of_people",
+          value: "30",
+        },
+        {
+          name: "book_restaurant_date",
+          value: "tomorrow",
+        },
+      ];
+      const currentStack = {
+        frame_id: "EPQQUPJA",
+        flow_id: "book_restaurant",
+        step_id: "3_collect_book_restaurant_time",
+        frame_type: "regular",
+        type: "flow",
+      };
+      const flow = {
+        id: "book_restaurant",
+        name: "book a restaurant",
+        description: "This flow books a restaurant",
+        steps: [
+          {
+            next: "1_collect_book_restaurant_number_of_people",
+            id: "0_collect_book_restaurant_name_of_restaurant",
+            collect: "book_restaurant_name_of_restaurant",
+            utter: "utter_ask_book_restaurant_name_of_restaurant",
+            ask_before_filling: false,
+            reset_after_flow_ends: true,
+          },
+          {
+            next: "2_collect_book_restaurant_date",
+            id: "1_collect_book_restaurant_number_of_people",
+            collect: "book_restaurant_number_of_people",
+            utter: "utter_ask_book_restaurant_number_of_people",
+            ask_before_filling: false,
+            reset_after_flow_ends: true,
+          },
+          {
+            next: "3_collect_book_restaurant_time",
+            id: "2_collect_book_restaurant_date",
+            collect: "book_restaurant_date",
+            utter: "utter_ask_book_restaurant_date",
+            ask_before_filling: false,
+            reset_after_flow_ends: true,
+          },
+          {
+            next: "4_collect_book_restaurant_is_date_flexible",
+            id: "3_collect_book_restaurant_time",
+            collect: "book_restaurant_time",
+            utter: "utter_ask_book_restaurant_time",
+            ask_before_filling: false,
+            reset_after_flow_ends: true,
+          },
+          {
+            next: "5_check_restaurant_availability",
+            id: "4_collect_book_restaurant_is_date_flexible",
+            description:
+              "(True/False) whether offering alternative dates make sense",
+            collect: "book_restaurant_is_date_flexible",
+            utter: "utter_ask_book_restaurant_is_date_flexible",
+            ask_before_filling: false,
+            reset_after_flow_ends: true,
+          },
+          {
+            next: [
+              {
+                if: "not is_restaurant_available",
+                then: [
+                  {
+                    next: "ask_alternative",
+                    id: "6_utter_restaurant_not_available",
+                    action: "utter_restaurant_not_available",
+                  },
+                  {
+                    next: "ask_alternative",
+                    id: "ask_alternative",
+                    description:
+                      "do not fill this slot, instead fill the given parts of the alternative into their respective slots",
+                    collect: "book_restaurant_alternative_dummy",
+                    utter: "utter_ask_book_restaurant_alternative_dummy",
+                    ask_before_filling: false,
+                    reset_after_flow_ends: true,
+                    rejections: [],
+                  },
+                ],
+              },
+              {
+                else: "available",
+              },
+            ],
+            id: "5_check_restaurant_availability",
+            action: "check_restaurant_availability",
+          },
+          {
+            next: "9_collect_book_restaurant_reservation_name",
+            id: "available",
+            action: "utter_restaurant_available",
+          },
+          {
+            next: "10_collect_book_restaurant_confirmation",
+            id: "9_collect_book_restaurant_reservation_name",
+            collect: "book_restaurant_reservation_name",
+            utter: "utter_ask_book_restaurant_reservation_name",
+            ask_before_filling: true,
+            reset_after_flow_ends: true,
+          },
+          {
+            next: [
+              {
+                if: "book_restaurant_confirmation",
+                then: [
+                  {
+                    next: "END",
+                    id: "11_utter_confirm_restaurant_booking",
+                    action: "utter_confirm_restaurant_booking",
+                  },
+                ],
+              },
+              {
+                else: [
+                  {
+                    next: "END",
+                    id: "12_utter_cancel_book_restaurant",
+                    action: "utter_cancel_book_restaurant",
+                  },
+                ],
+              },
+            ],
+            id: "10_collect_book_restaurant_confirmation",
+            collect: "book_restaurant_confirmation",
+            utter: "utter_ask_book_restaurant_confirmation",
+            ask_before_filling: true,
+            reset_after_flow_ends: true,
+          },
+        ],
+      };
+      const activeStep = "3_collect_book_restaurant_time";
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = formatFlow(slots, currentStack, flow, activeStep);
+      expect(result).toEqual(restaurantFlow);
+    });
+  });
+
+  describe("parseFieldUsingStack", () => {
+    test("should parse a filed using a stack", () => {
+      const fieldValue = "transfer_money_recipient";
+
+      expect(
+        parseFieldUsingStack("{{context.collect}}", {
+          frame_id: "frame_id",
+          flow_id: "flow_id",
+          step_id: "step_id",
+          collect: fieldValue,
+          ended: false,
+        })
+      ).toEqual(fieldValue);
+    });
+
+    test("should return the same field if it doesn't have `context`", () => {
+      const fieldValue = "transfer_money_recipient";
+
+      expect(
+        parseFieldUsingStack(fieldValue, {
+          frame_id: "frame_id",
+          flow_id: "flow_id",
+          step_id: "step_id",
+          ended: false,
+        })
+      ).toEqual(fieldValue);
+    });
+
+    test("should return the value if it has conditions as postfix", () => {
+      const fieldValue = "transfer_money_recipient";
+
+      expect(
+        parseFieldUsingStack("{{context.collect}} is not null", {
+          frame_id: "frame_id",
+          flow_id: "flow_id",
+          step_id: "step_id",
+          collect: fieldValue,
+          ended: false,
+        })
+      ).toEqual(`${fieldValue} is not null`);
+    });
+
+    test("should return the value if it has conditions as prefix", () => {
+      const fieldValue = "transfer_money_recipient";
+
+      expect(
+        parseFieldUsingStack("not {{context.collect}}", {
+          frame_id: "frame_id",
+          flow_id: "flow_id",
+          step_id: "step_id",
+          collect: fieldValue,
+          ended: false,
+        })
+      ).toEqual(`not ${fieldValue}`);
+    });
+  });
+});
+
+const restaurantFlow = `flowchart TD
+classDef collect stroke-width:1px
+classDef action fill:#FBFCFD,stroke:#A0B8CF
+classDef link fill:#f43
+classDef slot fill:#e8f3db,stroke:#c5e1a5
+classDef endstep fill:#ccc,stroke:#444
+classDef active stroke:#F8941A,stroke-width:3px,fill:#FFF8E0
+0_collect_book_restaurant_name_of_restaurant["book_restaurant_name_of_restaurant
+'fonfon'"]:::collect
+0_collect_book_restaurant_name_of_restaurant --> 1_collect_book_restaurant_number_of_people
+1_collect_book_restaurant_number_of_people["book_restaurant_number_of_people
+'30'"]:::collect
+1_collect_book_restaurant_number_of_people --> 2_collect_book_restaurant_date
+2_collect_book_restaurant_date["book_restaurant_date
+'tomorrow'"]:::collect
+2_collect_book_restaurant_date --> 3_collect_book_restaurant_time
+3_collect_book_restaurant_time["book_restaurant_time
+💬"]:::collect
+class 3_collect_book_restaurant_time active
+3_collect_book_restaurant_time --> 4_collect_book_restaurant_is_date_flexible
+4_collect_book_restaurant_is_date_flexible["book_restaurant_is_date_flexible
+'true'"]:::collect
+4_collect_book_restaurant_is_date_flexible --> 5_check_restaurant_availability
+5_check_restaurant_availability["check_restaurant_availability"]:::action
+5_check_restaurant_availability -->|not is_restaurant_available| 6_utter_restaurant_not_available
+6_utter_restaurant_not_available["utter_restaurant_not_available"]:::action
+6_utter_restaurant_not_available --> ask_alternative
+ask_alternative["book_restaurant_alternative_dummy
+💬"]:::collect
+ask_alternative --> ask_alternative
+END["🏁 END"]:::endstep
+5_check_restaurant_availability -->|else| available
+available["utter_restaurant_available"]:::action
+available --> 9_collect_book_restaurant_reservation_name
+9_collect_book_restaurant_reservation_name["book_restaurant_reservation_name
+💬"]:::collect
+9_collect_book_restaurant_reservation_name --> 10_collect_book_restaurant_confirmation
+10_collect_book_restaurant_confirmation["book_restaurant_confirmation
+💬"]:::collect
+10_collect_book_restaurant_confirmation -->|book_restaurant_confirmation| 11_utter_confirm_restaurant_booking
+11_utter_confirm_restaurant_booking["utter_confirm_restaurant_booking"]:::action
+11_utter_confirm_restaurant_booking --> END
+END["🏁 END"]:::endstep
+10_collect_book_restaurant_confirmation -->|else| 12_utter_cancel_book_restaurant
+12_utter_cancel_book_restaurant["utter_cancel_book_restaurant"]:::action
+12_utter_cancel_book_restaurant --> END
+END["🏁 END"]:::endstep
+END["🏁 END"]:::endstep
+`;

rasa/core/channels/inspector/src/helpers/formatters.ts

@@ -0,0 +1,306 @@
+import { rasaColors } from "../theme/base/colors";
+import type { Event, Flow, Slot, Stack } from "../types";
+
+export function formatSlots(slots: { [key: string]: unknown }) {
+  if (!slots) {
+    return [];
+  }
+
+  return Object.entries(slots)
+    .filter(
+      (slotDuple) =>
+        slotDuple[0] !== "dialogue_stack" &&
+        slotDuple[0] !== "flow_hashes" &&
+        slotDuple[1] != null
+    )
+    .map((slotDuple) => ({ name: slotDuple[0], value: slotDuple[1] }));
+}
+
+export const formatTestCases = (events: Event[], sessionId: string) => {
+  let testCases = `test_cases:
+  - test_case: ${sessionId}
+    steps:`;
+
+  const steps = events
+    .map((event) => {
+      const escapedText = JSON.stringify(event.text);
+      if (event.event === "user") {
+        return `    - user: ${escapedText}`;
+      } else if (event.event === "bot") {
+        return `${
+          event.metadata?.utter_action
+            ? `    - utter: ${event.metadata.utter_action}`
+            : `    - bot: ${escapedText}`
+        }`;
+      }
+    })
+    .filter(Boolean);
+
+  if (steps.length === 0) {
+    testCases = `${testCases} []`;
+  } else {
+    testCases = `${testCases}
+${steps.join("\n")}`;
+  }
+
+  return testCases;
+};
+
+function hashCode(str: string) {
+  var hash = 0,
+    i,
+    chr;
+  if (str.length === 0) return hash;
+  for (i = 0; i < str.length; i++) {
+    chr = str.charCodeAt(i);
+    hash = (hash << 5) - hash + chr;
+    hash |= 0; // Convert to 32bit integer
+  }
+  return hash;
+}
+
+function mermaidIdForTitle(title: string) {
+  return `id${hashCode(title)}`;
+}
+
+const encodeDoubleQuotes = (str: string) =>
+  /**
+   * Transforms all " characters of a string into html codes.
+   */
+  str.replace(/"/g, `#34;`);
+
+export const formatFlow = (
+  slots: Slot[],
+  currentStack?: Stack,
+  flow?: Flow,
+  stepTrail?: string[]
+) => {
+  const activeStep = currentStack?.step_id;
+
+  if (!flow) {
+    return "";
+  }
+
+  const mermaidText = [
+    `flowchart TD
+classDef collect stroke-width:1px
+classDef action fill:#FBFCFD,stroke:#A0B8CF
+classDef link fill:#f43
+classDef slot fill:#e8f3db,stroke:#c5e1a5
+classDef endstep fill:#ccc,stroke:#444
+classDef previous stroke:${rasaColors.rasaOrange[400]},stroke-width:1px
+classDef active stroke:${rasaColors.rasaOrange[400]},stroke-width:3px,fill:${rasaColors.warning[50]}
+`,
+  ];
+  try {
+    const text = renderStepSequence(
+      flow.steps,
+      slots,
+      currentStack,
+      activeStep,
+      stepTrail
+    );
+    mermaidText.push(text);
+    mermaidText.push(colorDoubleEdges(mermaidText.join("")));
+    return mermaidText.join("");
+  } catch (e) {
+    return `${mermaidText}\nA["Something went wrong!"]\nB["${e}"]`;
+  }
+};
+
+function truncate(str: string, limit = 35) {
+  // if a string is too long, use an ellipsis
+  if (str.length > limit) {
+    return str.substring(0, limit) + "...";
+  }
+  return str;
+}
+
+function colorDoubleEdges(mermaidText: string) {
+  // go through the lines of mermaid text. keep a counter counting edges
+  // ("-->"" or "==>"). if "==>" is found in a line, add the line number to
+  // a list.
+  const lines = mermaidText.split("\n");
+  const coloredEdges = [];
+  let edgeCounter = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes("-->")) {
+      edgeCounter++;
+    } else if (lines[i].includes("==>")) {
+      coloredEdges.push(edgeCounter);
+      edgeCounter++;
+    }
+  }
+  if(coloredEdges.length > 0) {
+    return `linkStyle ${coloredEdges.join(",")} stroke:${
+      rasaColors.rasaOrange[400]
+    }, ;\n`;
+  } else {
+    return "";
+  }
+}
+
+export function parseFieldUsingStack(name: string, stack?: Stack): string {
+  // name might be in the `{{context.field_in_stack}}` format so we're stripping everything except the field in the stack name
+  const parsedField = name.split(/{{context\.|}}/);
+  if (parsedField.length === 1) {
+    return parsedField[0];
+  }
+
+  const stackField = parsedField[1];
+
+  // @ts-expect-error `stack[stackField]` doesn't necessary exists this might return `undefined`
+  const stackValue = stack ? stack[stackField] : undefined;
+
+  // name might also be in the `condition {{context.field_in_stack}} condition` format
+  // so we want to keep that if there is any
+  if (parsedField[2] && parsedField[2] !== "") {
+    return `${parsedField[0]}${stackValue}${parsedField[2]}`;
+  }
+
+  return `${parsedField[0]}${stackValue}`;
+}
+
+function arrowTypeFor(stepId: string, nextId: string, stepTrail?: string[]) {
+  return stepTrail?.includes(stepId) && stepTrail?.includes(nextId)
+    ? "==>"
+    : "-->";
+}
+
+function renderStepSequence(
+  steps: Flow["steps"],
+  slots: Slot[],
+  currentStack?: Stack,
+  activeStep?: string,
+  stepTrail?: string[]
+) {
+  let hasUsedEndStep = false;
+  let mermaidTextFragment = "";
+  steps.forEach((step) => {
+    const stepId = parseFieldUsingStack(step.id, currentStack);
+    const mermaidId = mermaidIdForTitle(stepId);
+
+    if (step.collect) {
+      const slot = slots.find((slot) => slot.name === step.collect);
+      const slotValue =
+        slot && typeof slot.value === "string"
+          ? `"${encodeDoubleQuotes(truncate(slot.value))}"`
+          : "💬";
+      mermaidTextFragment += `${mermaidId}["${encodeDoubleQuotes(
+        truncate(parseFieldUsingStack(step.collect, currentStack))
+      )}\n${slotValue}"]:::collect\n`;
+    }
+
+    if (step.action) {
+      mermaidTextFragment += `${mermaidId}["${encodeDoubleQuotes(
+        truncate(parseFieldUsingStack(step.action, currentStack))
+      )}"]:::action\n`;
+    }
+
+    if (step.link) {
+      mermaidTextFragment += `${mermaidId}["\uD83D\uDD17 ${parseFieldUsingStack(
+        step.link,
+        currentStack
+      )}"]:::link\n`;
+    }
+
+    if (step.set_slots) {
+      mermaidTextFragment += `${mermaidId}["✍️ ${encodeDoubleQuotes(
+        stepId
+      )}"]:::slot\n`;
+    }
+
+    if (activeStep && stepId === activeStep) {
+      mermaidTextFragment += `class ${mermaidId} active\n`;
+    } else if (stepTrail?.includes(stepId)) {
+      mermaidTextFragment += `class ${mermaidId} previous\n`;
+    }
+
+    // if next is an id, then it is a link
+    if (step.next && typeof step.next === "string") {
+      const nextId = parseFieldUsingStack(step.next, currentStack);
+
+      mermaidTextFragment += `${mermaidId} ${arrowTypeFor(
+        stepId,
+        nextId,
+        stepTrail
+      )} ${mermaidIdForTitle(nextId)}\n`;
+      if (step.next == "END") {
+        hasUsedEndStep = true;
+      }
+    }
+
+    // if next is an array, then it is a list of conditions
+    if (step.next && Array.isArray(step.next)) {
+      step.next.forEach((condition) => {
+        if (condition.then && typeof condition.then === "string") {
+          mermaidTextFragment += `${mermaidId} ${arrowTypeFor(
+            stepId,
+            condition.then,
+            stepTrail
+          )}|"${encodeDoubleQuotes(
+            parseFieldUsingStack(condition.if, currentStack)
+          )}"| ${mermaidIdForTitle(condition.then)}\n`;
+          if (condition.then == "END") {
+            hasUsedEndStep = true;
+          }
+        } else if (condition.then) {
+          mermaidTextFragment += `${mermaidId} ${arrowTypeFor(
+            stepId,
+            condition.then[0].id,
+            stepTrail
+          )}|"${encodeDoubleQuotes(
+            parseFieldUsingStack(condition.if, currentStack)
+          )}"| ${mermaidIdForTitle(condition.then[0].id)}\n`;
+          mermaidTextFragment += renderStepSequence(
+            // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+            condition.then,
+            slots,
+            currentStack,
+            activeStep,
+            stepTrail
+          );
+        }
+
+        // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+        if (condition.else && typeof condition.else === "string") {
+          mermaidTextFragment += `${mermaidId} ${arrowTypeFor(
+            stepId,
+            // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+            condition.else,
+            stepTrail
+            // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+          )}|else| ${mermaidIdForTitle(condition.else)}\n`;
+          // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+          if (condition.else == "END") {
+            hasUsedEndStep = true;
+          }
+          // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+        } else if (condition.else) {
+          mermaidTextFragment += `${mermaidId} ${arrowTypeFor(
+            stepId,
+            // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+            condition.else[0].id,
+            stepTrail
+            // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+          )}|else| ${mermaidIdForTitle(condition.else[0].id)}\n`;
+          mermaidTextFragment += renderStepSequence(
+            // @ts-expect-error Currently the param for renderStepSequence only accepts a Step, for further improvements we need to change the type to know that it can also be a then step
+            condition.else,
+            slots,
+            currentStack,
+            activeStep,
+            stepTrail
+          );
+        }
+      });
+    }
+  });
+  if (hasUsedEndStep) {
+    mermaidTextFragment += `${mermaidIdForTitle("END")}["🏁 END"]:::endstep\n`;
+    if (activeStep && "END" === activeStep) {
+      mermaidTextFragment += `class ${mermaidIdForTitle("END")} active\n`;
+    }
+  }
+  return mermaidTextFragment;
+}