rasa-pro 3.13.0.dev5__py3-none-any.whl → 3.13.0.dev7__py3-none-any.whl

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

@@ -1,84 +1,84 @@
-import { rasaColors } from "../theme/base/colors";
-import type { Event, Flow, Slot, Stack } from "../types";
+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 []
   }
 
   return Object.entries(slots)
     .filter(
       (slotDuple) =>
-        slotDuple[0] !== "dialogue_stack" &&
-        slotDuple[0] !== "flow_hashes" &&
-        slotDuple[1] != null
+        slotDuple[0] !== 'dialogue_stack' &&
+        slotDuple[0] !== 'flow_hashes' &&
+        slotDuple[1] != null,
     )
-    .map((slotDuple) => ({ name: slotDuple[0], value: slotDuple[1] }));
+    .map((slotDuple) => ({ name: slotDuple[0], value: slotDuple[1] }))
 }
 
 export const formatTestCases = (events: Event[], sessionId: string) => {
   let testCases = `test_cases:
   - test_case: ${sessionId}
-    steps:`;
+    steps:`
 
   const steps = events
     .map((event) => {
-      const escapedText = JSON.stringify(event.text);
-      if (event.event === "user") {
-        return `    - user: ${escapedText}`;
-      } else if (event.event === "bot") {
+      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);
+    .filter(Boolean)
 
   if (steps.length === 0) {
-    testCases = `${testCases} []`;
+    testCases = `${testCases} []`
   } else {
     testCases = `${testCases}
-${steps.join("\n")}`;
+${steps.join('\n')}`
   }
 
-  return testCases;
-};
+  return testCases
+}
 
 function hashCode(str: string) {
   var hash = 0,
     i,
-    chr;
-  if (str.length === 0) return hash;
+    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
+    chr = str.charCodeAt(i)
+    hash = (hash << 5) - hash + chr
+    hash |= 0 // Convert to 32bit integer
   }
-  return hash;
+  return hash
 }
 
 function mermaidIdForTitle(title: string) {
-  return `id${hashCode(title)}`;
+  return `id${hashCode(title)}`
 }
 
 const encodeDoubleQuotes = (str: string) =>
   /**
    * Transforms all " characters of a string into html codes.
    */
-  str.replace(/"/g, `#34;`);
+  str.replace(/"/g, `#34;`)
 
 export const formatFlow = (
   slots: Slot[],
   currentStack?: Stack,
   flow?: Flow,
-  stepTrail?: string[]
+  stepTrail?: string[],
 ) => {
-  const activeStep = currentStack?.step_id;
+  const activeStep = currentStack?.step_id
 
   if (!flow) {
-    return "";
+    return ''
   }
 
   const mermaidText = [
@@ -91,189 +91,189 @@ 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("");
+      stepTrail,
+    )
+    mermaidText.push(text)
+    mermaidText.push(colorDoubleEdges(mermaidText.join('')))
+    return mermaidText.join('')
   } catch (e) {
-    return `${mermaidText}\nA["Something went wrong!"]\nB["${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.substring(0, limit) + '...'
   }
-  return str;
+  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;
+  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 (lines[i].includes('-->')) {
+      edgeCounter++
+    } else if (lines[i].includes('==>')) {
+      coloredEdges.push(edgeCounter)
+      edgeCounter++
     }
   }
-  if(coloredEdges.length > 0) {
-    return `linkStyle ${coloredEdges.join(",")} stroke:${
+  if (coloredEdges.length > 0) {
+    return `linkStyle ${coloredEdges.join(',')} stroke:${
       rasaColors.rasaOrange[400]
-    }, ;\n`;
+    }, ;\n`
   } else {
-    return "";
+    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\.|}}/);
+  const parsedField = name.split(/{{context\.|}}/)
   if (parsedField.length === 1) {
-    return parsedField[0];
+    return parsedField[0]
   }
 
-  const stackField = parsedField[1];
+  const stackField = parsedField[1]
 
   // @ts-expect-error `stack[stackField]` doesn't necessary exists this might return `undefined`
-  const stackValue = stack ? stack[stackField] : 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]}`;
+  if (parsedField[2] && parsedField[2] !== '') {
+    return `${parsedField[0]}${stackValue}${parsedField[2]}`
   }
 
-  return `${parsedField[0]}${stackValue}`;
+  return `${parsedField[0]}${stackValue}`
 }
 
 function arrowTypeFor(stepId: string, nextId: string, stepTrail?: string[]) {
   return stepTrail?.includes(stepId) && stepTrail?.includes(nextId)
-    ? "==>"
-    : "-->";
+    ? '==>'
+    : '-->'
 }
 
 function renderStepSequence(
-  steps: Flow["steps"],
+  steps: Flow['steps'],
   slots: Slot[],
   currentStack?: Stack,
   activeStep?: string,
-  stepTrail?: string[]
+  stepTrail?: string[],
 ) {
-  let hasUsedEndStep = false;
-  let mermaidTextFragment = "";
+  let hasUsedEndStep = false
+  let mermaidTextFragment = ''
   steps.forEach((step) => {
-    const stepId = parseFieldUsingStack(step.id, currentStack);
-    const mermaidId = mermaidIdForTitle(stepId);
+    const stepId = parseFieldUsingStack(step.id, currentStack)
+    const mermaidId = mermaidIdForTitle(stepId)
 
     if (step.collect) {
-      const slot = slots.find((slot) => slot.name === step.collect);
+      const slot = slots.find((slot) => slot.name === step.collect)
       const slotValue =
-        slot && typeof slot.value === "string"
+        slot && typeof slot.value === 'string'
           ? `"${encodeDoubleQuotes(truncate(slot.value))}"`
-          : "💬";
+          : '💬'
       mermaidTextFragment += `${mermaidId}["${encodeDoubleQuotes(
-        truncate(parseFieldUsingStack(step.collect, currentStack))
-      )}\n${slotValue}"]:::collect\n`;
+        truncate(parseFieldUsingStack(step.collect, currentStack)),
+      )}\n${slotValue}"]:::collect\n`
     }
 
     if (step.action) {
       mermaidTextFragment += `${mermaidId}["${encodeDoubleQuotes(
-        truncate(parseFieldUsingStack(step.action, currentStack))
-      )}"]:::action\n`;
+        truncate(parseFieldUsingStack(step.action, currentStack)),
+      )}"]:::action\n`
     }
 
     if (step.link) {
       mermaidTextFragment += `${mermaidId}["\uD83D\uDD17 ${parseFieldUsingStack(
         step.link,
-        currentStack
-      )}"]:::link\n`;
+        currentStack,
+      )}"]:::link\n`
     }
 
     if (step.set_slots) {
       mermaidTextFragment += `${mermaidId}["✍️ ${encodeDoubleQuotes(
-        stepId
-      )}"]:::slot\n`;
+        stepId,
+      )}"]:::slot\n`
     }
 
     if (activeStep && stepId === activeStep) {
-      mermaidTextFragment += `class ${mermaidId} active\n`;
+      mermaidTextFragment += `class ${mermaidId} active\n`
     } else if (stepTrail?.includes(stepId)) {
-      mermaidTextFragment += `class ${mermaidId} previous\n`;
+      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);
+    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;
+        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") {
+        if (condition.then && typeof condition.then === 'string') {
           mermaidTextFragment += `${mermaidId} ${arrowTypeFor(
             stepId,
             condition.then,
-            stepTrail
+            stepTrail,
           )}|"${encodeDoubleQuotes(
-            parseFieldUsingStack(condition.if, currentStack)
-          )}"| ${mermaidIdForTitle(condition.then)}\n`;
-          if (condition.then == "END") {
-            hasUsedEndStep = true;
+            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
+            stepTrail,
           )}|"${encodeDoubleQuotes(
-            parseFieldUsingStack(condition.if, currentStack)
-          )}"| ${mermaidIdForTitle(condition.then[0].id)}\n`;
+            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
-          );
+            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") {
+        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
+            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`;
+          )}|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;
+          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) {
@@ -281,26 +281,26 @@ function renderStepSequence(
             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
+            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`;
+          )}|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
-          );
+            stepTrail,
+          )
         }
-      });
+      })
     }
-  });
+  })
   if (hasUsedEndStep) {
-    mermaidTextFragment += `${mermaidIdForTitle("END")}["🏁 END"]:::endstep\n`;
-    if (activeStep && "END" === activeStep) {
-      mermaidTextFragment += `class ${mermaidIdForTitle("END")} active\n`;
+    mermaidTextFragment += `${mermaidIdForTitle('END')}["🏁 END"]:::endstep\n`
+    if (activeStep && 'END' === activeStep) {
+      mermaidTextFragment += `class ${mermaidIdForTitle('END')} active\n`
     }
   }
-  return mermaidTextFragment;
+  return mermaidTextFragment
 }

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

@@ -1,131 +1,148 @@
-import { SelectedStack, Stack, Event } from "../types";
-import { immutableJSONPatch} from 'immutable-json-patch'
+import { SelectedStack, Stack, Event } from '../types'
+import { immutableJSONPatch } from 'immutable-json-patch'
 
 export const shouldShowTooltip = (text: string) => {
   if (!text) {
-    return false;
+    return false
   }
 
-  const textLength = text.length;
+  const textLength = text.length
 
   if (textLength > 10 && textLength < 89) {
-    return true;
+    return true
   }
 
-  return false;
-};
+  return false
+}
 
-export const createHistoricalStack = (activeStack: Stack [], events: Event[]): Stack[]  => {
+export const createHistoricalStack = (
+  activeStack: Stack[],
+  events: Event[],
+): Stack[] => {
   let stackFrames = activeStack.map((frame) => ({
     ...frame,
     ended: false,
-  }));
+  }))
   // go through the events looking for flow_completed and append them to the stack
-  let historicalStack: Stack[] = [];
-  let pastStackFrames: Stack[] = [];
+  let historicalStack: Stack[] = []
+  let pastStackFrames: Stack[] = []
   for (const event of events) {
-    if (event.event === "restart") {
-      historicalStack = [];
-      stackFrames = [];
-    } else if (event.event === "stack") {
-      let stackUpdate = JSON.parse(event.update || "");
+    if (event.event === 'restart') {
+      historicalStack = []
+      stackFrames = []
+    } else if (event.event === 'stack') {
+      let stackUpdate = JSON.parse(event.update || '')
       historicalStack = immutableJSONPatch(historicalStack, stackUpdate)
       for (const frame of historicalStack) {
-        if(!frame.flow_id){
+        if (!frame.flow_id) {
           // this is not a stack frame from the flow handler
-          continue;
+          continue
         }
         // if the frame is already in stackFrames, skip it
-        if(stackFrames.find((f) => f.frame_id === frame.frame_id)) {
-          continue;
+        if (stackFrames.find((f) => f.frame_id === frame.frame_id)) {
+          continue
         }
         // if the frame is in pastStackFrames, update the step_id otherwise add it
-        const pastFrame = pastStackFrames.find((f) => f.frame_id === frame.frame_id)
-        if(pastFrame) {
-          pastFrame.step_id = frame.step_id;
-          continue;
+        const pastFrame = pastStackFrames.find(
+          (f) => f.frame_id === frame.frame_id,
+        )
+        if (pastFrame) {
+          pastFrame.step_id = frame.step_id
+          continue
         }
-        pastStackFrames.push({...frame, ended: true});
+        pastStackFrames.push({ ...frame, ended: true })
       }
     }
   }
   // filter out pattern_collect_information frames
-  pastStackFrames = pastStackFrames.filter((frame) => frame.flow_id !== "pattern_collect_information");
-  return [...pastStackFrames, ...stackFrames];
+  pastStackFrames = pastStackFrames.filter(
+    (frame) => frame.flow_id !== 'pattern_collect_information',
+  )
+  return [...pastStackFrames, ...stackFrames]
 }
 
 export const flowStepTrail = (events: Event[]): Record<string, string[]> => {
-  let stack: Stack[] = [];
+  let stack: Stack[] = []
   // mapping from flow id to the steps that were active in that flow
-  let activeSteps: { [key: string]: string[] } = {};
+  let activeSteps: { [key: string]: string[] } = {}
   for (const event of events) {
-    if (event.event === "restart") {
-      stack = [];
-      activeSteps = {};
-    } else if (event.event === "stack") {
-      let stackUpdate = JSON.parse(event.update || "");
+    if (event.event === 'restart') {
+      stack = []
+      activeSteps = {}
+    } else if (event.event === 'stack') {
+      let stackUpdate = JSON.parse(event.update || '')
       stack = immutableJSONPatch(stack, stackUpdate)
       if (stack.length > 0) {
-        let topFrame = stack[stack.length - 1];
+        let topFrame = stack[stack.length - 1]
         if (!topFrame.flow_id) {
           // this is not a stack frame from the flow handler
-          continue;
+          continue
         }
-        if (!activeSteps[topFrame.flow_id] || topFrame.step_id === "START") {
-          activeSteps[topFrame.flow_id] = [];
+        if (!activeSteps[topFrame.flow_id] || topFrame.step_id === 'START') {
+          activeSteps[topFrame.flow_id] = []
         }
         if (!activeSteps[topFrame.flow_id].includes(topFrame.step_id)) {
           activeSteps[topFrame.flow_id].push(topFrame.step_id)
         }
       }
-
     }
   }
-  return activeSteps;
-};
+  return activeSteps
+}
 
-export const updatedActiveFrame = (previous: SelectedStack | undefined, updatedStack: Stack[], events: Event[]) => {
+export const updatedActiveFrame = (
+  previous: SelectedStack | undefined,
+  updatedStack: Stack[],
+  events: Event[],
+) => {
   // try to find the currently active frame in the updated stack
   // if it isn't there anymore, we will show the first non-pattern frame
   // instead
 
   // reset previously active stack frame, if it was not user selected
-  if(!previous?.isUserSelected){
+  if (!previous?.isUserSelected) {
     previous = undefined
   }
 
   const activeFrame = updatedStack.find(
-    (stackFrame) => stackFrame.frame_id === previous?.stack.frame_id
-  );
+    (stackFrame) => stackFrame.frame_id === previous?.stack.frame_id,
+  )
   if (!activeFrame || activeFrame.ended) {
-    if (!updatedStack){
-      return undefined;
+    if (!updatedStack) {
+      return undefined
     }
     // iterate over the stack. select the first frame where the name does not
     // contain "pattern" and that has not
     // ended yet. If there is no such frame, select the topmost frame that has
     // not ended yet. If there is no such frame, select the topmost frame.
-    const updatedFrame = updatedStack.slice().reverse().find(
-      (frame) =>
-        !frame.flow_id?.startsWith("pattern_") && !frame.ended
-    ) || updatedStack.slice().reverse().find(
-      (frame) => !frame.ended
-    ) || updatedStack[updatedStack.length - 1];
+    const updatedFrame =
+      updatedStack
+        .slice()
+        .reverse()
+        .find(
+          (frame) => !frame.flow_id?.startsWith('pattern_') && !frame.ended,
+        ) ||
+      updatedStack
+        .slice()
+        .reverse()
+        .find((frame) => !frame.ended) ||
+      updatedStack[updatedStack.length - 1]
 
-    if(updatedFrame !== undefined) {
+    if (updatedFrame !== undefined) {
       return {
         stack: updatedFrame,
         isUserSelected: false,
         activatedSteps: flowStepTrail(events)[updatedFrame.flow_id] || [],
-      };
+      }
     } else {
-      return undefined;
+      return undefined
     }
   } else {
-    if(previous){
-      previous.activatedSteps = flowStepTrail(events)[previous.stack.flow_id] || [];
-      previous.stack = activeFrame;
+    if (previous) {
+      previous.activatedSteps =
+        flowStepTrail(events)[previous.stack.flow_id] || []
+      previous.stack = activeFrame
     }
-    return previous;
+    return previous
   }
-};
+}

rasa/core/channels/inspector/src/main.tsx

@@ -1,13 +1,13 @@
-import React from "react";
-import ReactDOM from "react-dom/client";
-import { App } from "./App.tsx";
-import { ChakraProvider } from "@chakra-ui/react";
-import { theme } from "./theme";
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { App } from './App.tsx'
+import { ChakraProvider } from '@chakra-ui/react'
+import { theme } from './theme'
 
-ReactDOM.createRoot(document.getElementById("root")!).render(
+ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>
     <ChakraProvider theme={theme}>
       <App />
     </ChakraProvider>
-  </React.StrictMode>
-);
+  </React.StrictMode>,
+)