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

rasa/anonymization/anonymization_rule_orchestrator.py

@@ -1,119 +0,0 @@
-import copy
-import json
-import logging
-from typing import Any, Dict, List, Optional, Text
-
-from rasa.anonymization.anonymization_rule_executor import (
-    AnonymizationRuleExecutor,
-    AnonymizationRuleList,
-)
-from rasa.core.brokers.broker import EventBroker
-from rasa.core.brokers.kafka import KafkaEventBroker
-
-logger = logging.getLogger(__name__)
-
-
-class AnonymizationRuleOrchestrator:
-    """Orchestrates the execution of anonymization rules."""
-
-    def __init__(
-        self,
-        event_broker: Optional[EventBroker],
-        anonymization_rule_list: AnonymizationRuleList,
-    ):
-        """Initializes the orchestrator."""
-        self.event_broker = (
-            event_broker if isinstance(event_broker, KafkaEventBroker) else None
-        )
-        self.anonymization_rule_executor = AnonymizationRuleExecutor(
-            anonymization_rule_list
-        )
-
-    def anonymize_event(self, event: Dict[Text, Any]) -> Dict[Text, Any]:
-        """Anonymizes one of the supported event types.
-
-        The supported event types: user, bot, slot, entities.
-        """
-        event_copy = copy.deepcopy(event)
-        event_type = event["event"]
-
-        if event_type == "user" or event_type == "bot":
-            if event["text"] is None:
-                return event_copy
-
-            anonymized_text = self.anonymization_rule_executor.run(event["text"])
-            event_copy["text"] = anonymized_text
-
-            if "parse_data" in event_copy:
-                event_copy["parse_data"]["text"] = anonymized_text
-
-                entities = event_copy["parse_data"]["entities"]
-
-                if entities:
-                    anonymized_entities = self._anonymize_entities(entities)
-                    event_copy["parse_data"]["entities"] = anonymized_entities
-
-        elif event_type == "slot":
-            slot_value = event["value"]
-
-            if slot_value is None:
-                return event_copy
-            elif not isinstance(slot_value, str):
-                slot_value = json.dumps(slot_value)
-
-            anonymized_value = self.anonymization_rule_executor.run(slot_value)
-            event_copy["value"] = anonymized_value
-
-        elif event_type == "entities":
-            entities = event_copy["entities"]
-            anonymized_entities = self._anonymize_entities(entities)
-
-            event_copy["entities"] = anonymized_entities
-        else:
-            logger.debug(f"Unsupported event type for anonymization: {event_type}.")
-
-        return event_copy
-
-    def publish_event(
-        self, anonymized_event: Dict[Text, Any], is_anonymized: bool
-    ) -> None:
-        """Publishes the anonymized event to the event broker."""
-        if self.event_broker is None:
-            return None
-
-        # this assumes that the event broker's topic attribute
-        # is set to the correct anonymization topic
-        if is_anonymized:
-            event_type = anonymized_event["event"]
-            sender_id = anonymized_event["sender_id"]
-            logger.debug(
-                f"Publishing event of type '{event_type}' from "
-                f"sender ID '{sender_id}' to "
-                f"Kafka topic '{self.event_broker.topic}'. "
-                f"The anonymization pipeline used rule named "
-                f"'{self.anonymization_rule_executor.anonymization_rule_list.id}'."
-            )
-
-        self.event_broker.publish(anonymized_event)
-
-    def _anonymize_entities(
-        self, entities: List[Dict[Text, Any]]
-    ) -> List[Dict[Text, Any]]:
-        """Anonymizes entities."""
-        anonymized_entities = []
-
-        for entity in entities:
-            entity_value = entity.get("value")
-
-            if entity_value is not None:
-                value = self.anonymization_rule_executor.run(str(entity_value))
-                entity["value"] = value
-                anonymized_entities.append(entity)
-
-        return anonymized_entities
-
-    def anonymize_log_message(self, message: Text) -> Any:
-        """Anonymizes log messages."""
-        if self.event_broker:
-            return None
-        return self.anonymization_rule_executor.run(message)

rasa/anonymization/schemas/config.yml

@@ -1,47 +0,0 @@
-allowempty: True
-mapping:
-  anonymization:
-    type: "map"
-    mapping:
-      rule_lists:
-        type: "seq"
-        matching: "any"
-        required: True
-        sequence:
-        - type: "map"
-          mapping:
-            id:
-              type: "str"
-              required: True
-            rules:
-              type: "seq"
-              required: True
-              matching: "any"
-              sequence:
-              - type: "map"
-                mapping:
-                  entity:
-                    type: "str"
-                    required: True
-                  substitution:
-                    type: "str"
-                    enum: ["text", "mask", "faker"]
-                    required: False
-                  value:
-                    type: "str"
-                    required: False
-
-      metadata:
-        type: "map"
-        required: True
-        mapping:
-          language:
-            type: "str"
-            required: True
-          model_name:
-            type: "any"
-            required: True
-          model_provider:
-            type: "str"
-            required: True
-            enum: ["spacy", "stanza", "transformers"]

rasa/anonymization/utils.py

@@ -1,118 +0,0 @@
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, Optional, Text
-
-from rasa.shared.exceptions import RasaException, YamlException
-from rasa.shared.utils.yaml import (
-    read_config_file,
-    read_yaml_file,
-    validate_yaml_content_using_schema,
-)
-
-logger = logging.getLogger(__name__)
-SCHEMA_FILE = Path(__file__).parent / "schemas" / "config.yml"
-
-
-def read_endpoint_config(
-    filename: Optional[Text], endpoint_type: Text
-) -> Optional[Dict[Text, Any]]:
-    """Reads a configuration file from disk and extract one config."""
-    if not filename:
-        return None
-
-    try:
-        content = read_config_file(filename, reader_type=["safe", "rt"])
-
-        if content.get(endpoint_type) is None:
-            return None
-
-        return content
-    except FileNotFoundError:
-        logger.error(
-            "Failed to read configuration from {}. No such file.".format(
-                os.path.abspath(filename)
-            ),
-        )
-        return None
-
-
-def extract_anonymization_traits(
-    anonymization_config: Optional[Dict[Text, Any]], endpoint_type: Text
-) -> Dict[Text, Any]:
-    """Extract anonymization traits from the anonymization config.
-
-    Args:
-        anonymization_config: The anonymization config.
-        endpoint_type: The endpoint type.
-
-    Returns:
-        A dictionary containing the anonymization traits.
-    """
-    if not anonymization_config:
-        return {"enabled": False}
-
-    anonymization_value = anonymization_config.get(endpoint_type)
-    if not anonymization_value:
-        logger.debug("Anonymization config found but nothing is defined.")
-        return {"enabled": False}
-
-    try:
-        validate_anonymization_yaml(anonymization_config)
-    except RasaException as exception:
-        logger.debug(exception)
-        return {"enabled": False}
-
-    rule_lists = anonymization_value.get("rule_lists", [])
-
-    traits = {
-        "enabled": True,
-        "metadata": anonymization_value.get("metadata", {}),
-        "number_of_rule_lists": len(rule_lists),
-        "number_of_rules": 0,
-        "substitutions": {
-            "mask": 0,
-            "faker": 0,
-            "text": 0,
-            "not_defined": 0,
-        },
-        "entities": set(),
-    }
-
-    for rule_list in rule_lists:
-        traits["number_of_rules"] += len(rule_list.get("rules", []))
-        for rule in rule_list.get("rules", []):
-            traits["substitutions"][rule.get("substitution", "not_defined")] += 1
-            traits["entities"].add(rule.get("entity"))
-
-    entities = list(traits["entities"])
-    entities.sort()
-    traits["entities"] = entities
-
-    return traits
-
-
-def validate_anonymization_yaml(yaml_content: Dict[Text, Any]) -> None:
-    """Checks if the yaml_content adheres to the anonymization rule schema.
-
-    If the yaml_content is not in the right format, an exception will be raised.
-    """
-    schema = read_yaml_file(SCHEMA_FILE, reader_type=("safe", "rt"))
-    try:
-        validate_yaml_content_using_schema(yaml_content, schema)
-    except YamlException as exception:
-        raise RasaException(
-            f"Invalid configuration for `anonymization_rules` : {exception}"
-        ) from exception
-
-    rule_lists = yaml_content.get("anonymization", {}).get("rule_lists", [])
-
-    rule_set = set()
-    for rule_list in rule_lists:
-        rule_id = rule_list.get("id")
-        if rule_id in rule_set:
-            raise RasaException(
-                f"Invalid configuration for `anonymization_rules` :"
-                f"Duplicate rule id: '{rule_id}' encountered in rule_lists"
-            )
-        rule_set.add(rule_id)

rasa/core/channels/inspector/dist/assets/channel-dfa68278.js

@@ -1 +0,0 @@
-import{aI as o,aJ as r}from"./index-3a23e736.js";const s=(a,n)=>o.lang.round(r.parse(a)[n]),e=s;export{e as c};

rasa/core/channels/inspector/dist/assets/clone-edb7f119.js

@@ -1 +0,0 @@
-import{c as r}from"./graph-4ede11ff.js";var e=4;function a(o){return r(o,e)}export{a as c};

rasa/core/channels/inspector/dist/assets/flowDiagram-v2-96b9c2cf-65e7c670.js

@@ -1 +0,0 @@
-import{p as e,f as o}from"./flowDb-956e92f1-10044f05.js";import{f as t,g as a}from"./styles-c10674c1-7b3680cf.js";import{u as i}from"./index-3a23e736.js";import"./graph-4ede11ff.js";import"./layout-dd48f7f4.js";import"./index-3862675e-65549d37.js";import"./clone-edb7f119.js";import"./edges-e0da2a9e-5a8b0749.js";import"./createText-2e5e7dd3-87c4ece5.js";import"./line-1569ad2c.js";import"./array-9f3ba611.js";import"./path-53f90ab3.js";import"./channel-dfa68278.js";const M={parser:e,db:o,renderer:t,styles:a,init:r=>{r.flowchart||(r.flowchart={}),r.flowchart.arrowMarkerAbsolute=r.arrowMarkerAbsolute,i({flowchart:{arrowMarkerAbsolute:r.arrowMarkerAbsolute}}),t.setConf(r.flowchart),o.clear(),o.setGen("gen-2")}};export{M as diagram};

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

@@ -1,191 +0,0 @@
-const bufferSize = 4096
-const sampleRate = 8000
-const audioOptions = {
-  audio: {
-    echoCancellation: true,
-    noiseSuppression: true,
-    autoGainControl: true
-  }
-}
-
-const arrayBufferToBase64 = ( buffer: ArrayBuffer ): string => {
-    let binary = '';
-    const bytes = new Uint8Array( buffer );
-    const len = bytes.byteLength;
-    for (let i = 0; i < len; i++) {
-        binary += String.fromCharCode( bytes[ i ] );
-    }
-    return window.btoa( binary );
-}
-
-const base64ToArrayBuffer = ( s: string ): ArrayBuffer => {
-    const binary_string =  window.atob(s);
-    const len = binary_string.length;
-    const bytes = new Uint8Array( len );
-    for (let i = 0; i < len; i++)        {
-        bytes[i] = binary_string.charCodeAt(i);
-    }
-    return bytes.buffer;
-}
-
-const floatToIntArray = (arr: Float32Array): Int32Array => {
-  // Convert Float Array [-1, 1] to full range int array
-  return Int32Array.from(arr, x => x * 0x7fffffff)
-}
-
-const intToFloatArray = (arr: Int32Array): Float32Array => {
-  return Float32Array.from(arr, x => (x / 0x7fffffff))
-}
-
-interface Mark {
-    id: string
-    bytesToGo: number
-}
-
-interface AudioQueue {
-  buffer: Float32Array;
-  marks: Array<Mark>
-  socket: WebSocket,
-  write: (newAudio: Float32Array) => void;
-  read: (nSamples: number) => Float32Array;
-  length: () => number;
-  addMarker: (id: string) => void;
-  reduceMarkers: (bytesRead: number) => void;
-  popMarkers: () => void;
-}
-
-
-const createAudioQueue = (socket: WebSocket) : AudioQueue => {
-  return {
-    buffer: new Float32Array(0),
-    marks: new Array<Mark>(),
-    socket,
-
-    write: function(newAudio: Float32Array) {
-      const currentQLength = this.buffer.length;
-      const newBuffer = new Float32Array(currentQLength + newAudio.length);
-      newBuffer.set(this.buffer, 0);
-      newBuffer.set(newAudio, currentQLength);
-      this.buffer = newBuffer;
-    },
-
-    read: function(nSamples: number) {
-      const samplesToPlay = this.buffer.subarray(0, nSamples);
-      this.buffer = this.buffer.subarray(nSamples, this.buffer.length);
-      this.reduceMarkers(samplesToPlay.length)
-      this.popMarkers()
-      return samplesToPlay;
-    },
-
-    length: function() {
-      return this.buffer.length;
-    },
-
-    addMarker: function(id: string) {
-        this.marks.push({id, bytesToGo: this.length()})
-    },
-
-    reduceMarkers: function(bytesRead: number) {
-        this.marks = this.marks.map((m) => {
-            return {id: m.id, bytesToGo: m.bytesToGo - bytesRead}
-        })
-    },
-
-    popMarkers: function() {
-        // marks are ordered
-        let popUpTo = 0;
-        while (popUpTo < this.marks.length) {
-            if (this.marks[popUpTo].bytesToGo <= 0) {
-                popUpTo += 1
-            } else {
-                break
-            }
-        }
-        const marksToPop = this.marks.slice(0, popUpTo)
-        this.marks = this.marks.slice(popUpTo, this.marks.length)
-        marksToPop.forEach((m) => {
-            this.socket.send(JSON.stringify({marker: m.id}))
-        })
-    }
-
-  };
-}
-
-const streamMicrophoneToServer = async (socket: WebSocket) => {
-  let audioStream = null;
-  const audioContext = new AudioContext({sampleRate});
-
-  try {
-    audioStream = await navigator.mediaDevices.getUserMedia(audioOptions);
-    const audioInput = audioContext.createMediaStreamSource(audioStream)
-    const sender = audioContext.createScriptProcessor(bufferSize, 1, 1)
-    sender.onaudioprocess = function(event) {
-      const message = JSON.stringify({
-        "audio": arrayBufferToBase64(floatToIntArray(event.inputBuffer.getChannelData(0)).buffer)
-      })
-      socket.send(message)
-    }
-    audioInput.connect(sender)
-    sender.connect(audioContext.destination)
-  } catch (err) {
-    console.error(err);
-  }
-}
-
-const setupAudioPlayback = (socket: WebSocket): AudioQueue => {
-  const audioQueue = createAudioQueue(socket)
-  const silence = new Float32Array(bufferSize)
-  const audioOutputContext = new AudioContext({sampleRate})
-  const scriptNode = audioOutputContext.createScriptProcessor(bufferSize, 1, 1);
-  scriptNode.onaudioprocess = function(e) {
-    const audioData = audioQueue.length() ? audioQueue.read(bufferSize) : silence
-    e.outputBuffer.getChannelData(0).set(audioData);
-  }
-  scriptNode.connect(audioOutputContext.destination)
-  return audioQueue
-}
-
-const addDataToAudioQueue = (audioQueue: AudioQueue) => (message: MessageEvent<any>) => {
-    const data = JSON.parse(message.data.toString())
-    if (data["audio"]) {
-      const audioBytes = base64ToArrayBuffer(data["audio"])
-      const audioData = intToFloatArray(new Int32Array(audioBytes))
-      audioQueue.write(audioData);
-    } else if (data["marker"]) {
-        audioQueue.addMarker(data["marker"])
-    }
-}
-
-/**
- * Constructs a WebSocket URL for browser audio from a base HTTP/HTTPS URL
- * 
- * @param baseUrl - The base URL (e.g., "https://example.com" or "http://localhost:5005")
- * @returns WebSocket URL for browser audio endpoint
- * 
- * @example
- * getWebSocketUrl("https://example.com")
- * // Returns: "wss://example.com/webhooks/browser_audio/websocket"
- * 
- * getWebSocketUrl("http://localhost:5005")
- * // Returns: "ws://localhost:5005/webhooks/browser_audio/websocket"
- * 
- * @throws {TypeError} If baseUrl is not a valid URL
- */
-export function getWebSocketUrl(baseUrl: string) {
-  const url = new URL(baseUrl);
-  const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-  return `${wsProtocol}//${url.host}/webhooks/browser_audio/websocket`;
-}
-
-/**
- * Creates a WebSocket connection for browser audio and streams microphone input to the server
- * 
- * @param baseUrl - The base URL (e.g., "https://example.com" or "http://localhost:5005")
- */
-export async function createAudioConnection(baseUrl: string) {
-  const websocketURL = getWebSocketUrl(baseUrl)
-  const socket = new WebSocket(websocketURL)
-  socket.onopen = async () => { await streamMicrophoneToServer(socket)}
-  const audioQueue = setupAudioPlayback(socket)
-  socket.onmessage = addDataToAudioQueue(audioQueue)
-}