rasa-pro 3.13.1a14__py3-none-any.whl → 3.13.1a16__py3-none-any.whl

rasa/builder/training_service.py

@@ -9,7 +9,7 @@ from rasa.builder import config
 from rasa.builder.exceptions import AgentLoadError, TrainingError
 from rasa.core import agent
 from rasa.core.utils import AvailableEndpoints, read_endpoints_from_path
-from rasa.model_training import train
+from rasa.model_training import TrainingResult, train
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
 
@@ -55,7 +55,7 @@ async def train_and_load_agent(importer: TrainingDataImporter) -> agent.Agent:
         raise TrainingError(f"SystemExit during training: {e}")
 
 
-async def _setup_endpoints():
+async def _setup_endpoints() -> None:
     """Setup endpoints configuration for training."""
     try:
         with tempfile.NamedTemporaryFile(
@@ -75,7 +75,7 @@ async def _setup_endpoints():
         raise TrainingError(f"Failed to setup endpoints: {e}")
 
 
-async def _train_model(importer: TrainingDataImporter):
+async def _train_model(importer: TrainingDataImporter) -> TrainingResult:
     """Train the Rasa model."""
     try:
         structlogger.info("training.started")

rasa/cli/inspect.py

@@ -9,6 +9,7 @@ from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
 from rasa.core import constants
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.exceptions import ModelNotFound
 from rasa.model import get_local_model
@@ -83,6 +84,12 @@ def inspect(args: argparse.Namespace) -> None:
 
     model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
 
+    # Load endpoints with proper endpoint file location
+    # This will initialise the endpoints singleton properly so that
+    # it can be used safely throughout the codebase with
+    # `AvailableEndpoints.get_instance()`
+    AvailableEndpoints.get_instance(args.endpoints)
+
     try:
         model = get_local_model(model)
     except ModelNotFound:

rasa/cli/project_templates/telco/actions/actions_billing.py

@@ -1,16 +1,17 @@
 import csv
 import logging
 from datetime import datetime
+from typing import Dict, List
 
 from rasa_sdk import Action
 from rasa_sdk.events import SlotSet
 
 
 class ActionVerifyBillByDate(Action):
-    def name(self):
+    def name(self) -> str:
         return "action_verify_bill_by_date"
 
-    def text_to_date(month_text):
+    def text_to_date(self, month_text: str) -> str:
         try:
             # Get the current year
             current_year = datetime.now().year
@@ -28,7 +29,7 @@ class ActionVerifyBillByDate(Action):
         except ValueError:
             return "Invalid format. Please use a full month name (e.g., 'March')."
 
-    def run(self, dispatcher, tracker, domain):
+    def run(self, dispatcher, tracker, domain) -> List[Dict]:
         # Get customer ID and date from slots
         customer_id = tracker.get_slot("customer_id")
         bill_month = tracker.get_slot("bill_month")
@@ -113,10 +114,10 @@ class ActionVerifyBillByDate(Action):
 
 
 class ActionRecapBill(Action):
-    def name(self):
+    def name(self) -> str:
         return "action_recap_bill"
 
-    def run(self, dispatcher, tracker, domain):
+    def run(self, dispatcher, tracker, domain) -> List[Dict]:
         # Get customer_id and bill_date from slots
         customer_id = tracker.get_slot("customer_id")
         bill_month = tracker.get_slot("bill_month")

rasa/cli/project_templates/telco/actions/actions_get_data_from_db.py

@@ -1,14 +1,15 @@
 import csv
+from typing import Dict, List
 
 from rasa_sdk import Action
 from rasa_sdk.events import SlotSet
 
 
 class ActionGetCustomerInfo(Action):
-    def name(self):
+    def name(self) -> str:
         return "action_get_customer_info"
 
-    def run(self, dispatcher, tracker, domain):
+    def run(self, dispatcher, tracker, domain) -> List[Dict]:
         # Load CSV file
         file_path = "csvs/customers.csv"  # get information from your DBs
         customer_id = tracker.get_slot("customer_id")

rasa/cli/shell.py

@@ -6,6 +6,7 @@ from typing import List
 from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.exceptions import ModelNotFound
 from rasa.model import get_local_model
@@ -105,7 +106,11 @@ def shell(args: argparse.Namespace) -> None:
     from rasa.shared.constants import DEFAULT_MODELS_PATH
 
     args.connector = "cmdline"
-
+    # Load endpoints with proper endpoint file location
+    # This will initialise the endpoints singleton properly so that
+    # it can be used safely throughout the codebase with
+    # `AvailableEndpoints.get_instance()`
+    AvailableEndpoints.get_instance(args.endpoints)
     model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
 
     try:

rasa/cli/train.py

@@ -112,6 +112,10 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
     )
     config = rasa.cli.utils.get_validated_config(args.config, CONFIG_MANDATORY_KEYS)
 
+    # Validates and loads endpoints with proper endpoint file location
+    # This will initialise the endpoints singleton properly so that
+    # it can be used safely throughout the codebase with
+    # `AvailableEndpoints.get_instance()`
     _check_nlg_endpoint_validity(args.endpoints)
 
     training_files = [

rasa/core/tracker_stores/dynamo_tracker_store.py

@@ -109,7 +109,35 @@ class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
         await self.stream_events(tracker)
         serialized = self.serialise_tracker(tracker)
 
-        self.db.put_item(Item=serialized)
+        full_tracker = await self.retrieve_full_tracker(tracker.sender_id)
+        if full_tracker is None:
+            self.db.put_item(Item=serialized)
+            return None
+
+        # return the latest events since the last user message
+        new_tracker = DialogueStateTracker.from_dict(
+            serialized["sender_id"], events_as_dict=serialized["events"]
+        )
+        new_events = new_tracker.get_last_turn_events()
+        new_serialized_events = [event.as_dict() for event in new_events]
+
+        # we need to save the full tracker if it is a new tracker
+        # without events following a user message
+        if not new_serialized_events:
+            self.db.put_item(Item=serialized)
+            return None
+
+        # append new events to the existing tracker
+        self.db.update_item(
+            Key={"sender_id": tracker.sender_id},
+            UpdateExpression="SET events = list_append(if_not_exists(events, :empty_list), :events)",  # noqa: E501
+            ExpressionAttributeValues={
+                ":events": new_serialized_events,
+                ":empty_list": [],
+            },
+            ReturnValues="UPDATED_NEW",
+        )
+        return None
 
     async def delete(self, sender_id: Text) -> None:
         """Delete tracker for the given sender_id."""
@@ -181,7 +209,7 @@ class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
                 events = rasa.utils.json_utils.replace_decimals_with_floats(
                     dialogue["events"]
                 )
-                events_with_floats += events
+                events_with_floats.extend(events)
 
         if self.domain is None:
             slots = []

rasa/model_manager/model_api.py

@@ -39,7 +39,6 @@ from rasa.model_manager.trainer_service import (
     update_training_status,
 )
 from rasa.model_manager.utils import (
-    InvalidPathException,
     get_logs_content,
     logs_base_path,
     models_base_path,
@@ -52,7 +51,7 @@ from rasa.server import ErrorResponse
 from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
 from rasa.studio.upload import build_calm_import_parts
-from rasa.utils.io import subpath
+from rasa.utils.io import InvalidPathException, subpath
 
 dotenv.load_dotenv()
 

rasa/shared/core/trackers.py

@@ -1170,6 +1170,23 @@ class DialogueStateTracker:
                 "Example: `language: en`."
             )
 
+    def get_last_turn_events(self) -> List[Event]:
+        """Get all events of the last conversation turn."""
+        last_user_message = self.get_last_event_for(
+            UserUttered, event_verbosity=EventVerbosity.ALL
+        )
+        if not last_user_message:
+            return []
+
+        last_turn_events = []
+        for event in reversed(self.events):
+            if event.timestamp >= last_user_message.timestamp:
+                last_turn_events.append(event)
+            else:
+                break
+
+        return list(reversed(last_turn_events))
+
 
 class TrackerEventDiffEngine:
     """Computes event difference of two trackers."""

rasa/shared/importers/utils.py

@@ -1,9 +1,37 @@
-from typing import Iterable, List, Optional, Text
+from typing import Any, Dict, Iterable, List, Optional, Text
+
+from pydantic import BaseModel, Field
 
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.yaml_flows_io import get_flows_as_json
 from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.utils.json_utils import extract_values
+
+
+class CALMUserData(BaseModel):
+    """All pieces that will be uploaded to Rasa Studio."""
+
+    flows: Dict[str, Any] = Field(default_factory=dict)
+    domain: Dict[str, Any] = Field(default_factory=dict)
+    config: Dict[str, Any] = Field(default_factory=dict)
+    endpoints: Dict[str, Any] = Field(default_factory=dict)
+    nlu: Dict[str, Any] = Field(default_factory=dict)
+
+
+DOMAIN_KEYS = [
+    "version",
+    "actions",
+    "responses",
+    "slots",
+    "intents",
+    "entities",
+    "forms",
+    "session_config",
+]
 
 
 def training_data_from_paths(paths: Iterable[Text], language: Text) -> TrainingData:
@@ -34,3 +62,51 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
         )
     flows.validate()
     return flows
+
+
+def extract_calm_import_parts_from_importer(
+    importer: TrainingDataImporter,
+    config: Optional[Dict[str, Any]] = None,
+    endpoints: Optional[Dict[str, Any]] = None,
+) -> CALMUserData:
+    """Extracts CALMUserData from a TrainingDataImporter.
+
+    Args:
+        importer: The training data importer
+        data_paths: The path(s) to the training data for flows
+        config: Optional config dict, if not provided will use importer.get_config()
+        endpoints: Optional endpoints dict, defaults to empty dict
+
+    Returns:
+        CALMUserData containing flows, domain, config, endpoints, and nlu data
+    """
+    # Extract config
+    if config is None:
+        config = importer.get_config()
+
+    # Extract domain
+    domain_from_files = importer.get_user_domain().as_dict()
+    domain = extract_values(domain_from_files, DOMAIN_KEYS)
+
+    # Extract flows
+    flows = importer.get_user_flows()
+    flows_dict = get_flows_as_json(flows)
+
+    # Extract NLU data
+    nlu_data = importer.get_nlu_data()
+    nlu_examples = nlu_data.filter_training_examples(
+        lambda ex: ex.get("intent") in nlu_data.intents
+    )
+    nlu_dict = RasaYAMLWriter().training_data_to_dict(nlu_examples)
+
+    # Use provided endpoints or default to empty dict
+    if endpoints is None:
+        endpoints = {}
+
+    return CALMUserData(
+        flows=flows_dict or {},
+        domain=domain or {},
+        config=config or {},
+        endpoints=endpoints or {},
+        nlu=nlu_dict or {},
+    )

rasa/studio/upload.py

@@ -7,7 +7,6 @@ from typing import Any, Dict, Iterable, List, Optional, Set, Text, Tuple, Union
 import questionary
 import requests
 import structlog
-from pydantic import BaseModel, Field
 
 import rasa.cli.telemetry
 import rasa.cli.utils
@@ -24,9 +23,13 @@ from rasa.shared.constants import (
     DEFAULT_DOMAIN_PATHS,
 )
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader, YamlFlowsWriter
+from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 from rasa.shared.exceptions import RasaException
-from rasa.shared.importers.importer import FlowSyncImporter, TrainingDataImporter
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.importers.utils import (
+    CALMUserData,
+    extract_calm_import_parts_from_importer,
+)
 from rasa.shared.nlu.training_data.formats.rasa_yaml import (
     RasaYAMLReader,
     RasaYAMLWriter,
@@ -34,7 +37,6 @@ from rasa.shared.nlu.training_data.formats.rasa_yaml import (
 from rasa.shared.utils.llm import collect_custom_prompts
 from rasa.shared.utils.yaml import (
     dump_obj_as_yaml_to_string,
-    read_yaml,
     read_yaml_file,
 )
 from rasa.studio import results_logger
@@ -43,6 +45,7 @@ from rasa.studio.config import StudioConfig
 from rasa.studio.results_logger import StudioResult, with_studio_error_handler
 from rasa.studio.utils import validate_argument_paths
 from rasa.telemetry import track_upload_to_studio_failed
+from rasa.utils.json_utils import extract_values
 
 structlogger = structlog.get_logger()
 
@@ -68,16 +71,6 @@ DOMAIN_KEYS = [
 ]
 
 
-class CALMImportParts(BaseModel):
-    """All pieces that will be uploaded to Rasa Studio."""
-
-    flows: Dict[str, Any]
-    domain: Dict[str, Any]
-    config: Dict[str, Any]
-    endpoints: Dict[str, Any]
-    nlu: Dict[str, Any] = Field(default_factory=dict)
-
-
 def _get_selected_entities_and_intents(
     args: argparse.Namespace,
     intents_from_files: Set[Text],
@@ -171,6 +164,7 @@ def handle_upload(args: argparse.Namespace) -> None:
 
     config = read_yaml_file(args.config, expand_env_vars=False)
     assistant_name = args.assistant_name or _get_assistant_name(config)
+    args.assistant_name = assistant_name
     if not _handle_existing_assistant(
         assistant_name, studio_config.studio_url, verify, args
     ):
@@ -193,11 +187,6 @@ config_keys = [
 ]
 
 
-def extract_values(data: Dict, keys: List[Text]) -> Dict:
-    """Extracts values for given keys from a dictionary."""
-    return {key: data.get(key) for key in keys if data.get(key)}
-
-
 def _get_assistant_name(config: Dict[Text, Any]) -> str:
     config_assistant_id = config.get("assistant_id", "")
     assistant_name = questionary.text(
@@ -236,7 +225,7 @@ def build_calm_import_parts(
     config_path: Text,
     endpoints_path: Optional[Text] = None,
     assistant_name: Optional[Text] = None,
-) -> Tuple[str, CALMImportParts]:
+) -> Tuple[str, CALMUserData]:
     """Builds the parts of the assistant to be uploaded to Studio.
 
     Args:
@@ -259,33 +248,10 @@ def build_calm_import_parts(
     endpoints = read_yaml_file(endpoints_path, expand_env_vars=False)
     assistant_name = assistant_name or _get_assistant_name(config)
 
-    domain_from_files = importer.get_user_domain().as_dict()
-    domain = extract_values(domain_from_files, DOMAIN_KEYS)
-
-    flow_importer = FlowSyncImporter.load_from_dict(
-        training_data_paths=[str(data_path)], expand_env_vars=False
-    )
-
-    flows = list(flow_importer.get_user_flows())
-    flows_yaml = YamlFlowsWriter().dumps(flows)
-    flows = read_yaml(flows_yaml, expand_env_vars=False)
-
-    nlu_importer = TrainingDataImporter.load_from_dict(
-        training_data_paths=[str(data_path)], expand_env_vars=False
-    )
-    nlu_data = nlu_importer.get_nlu_data()
-    nlu_examples = nlu_data.filter_training_examples(
-        lambda ex: ex.get("intent") in nlu_data.intents
-    )
-    nlu_examples_yaml = RasaYAMLWriter().dumps(nlu_examples)
-    nlu = read_yaml(nlu_examples_yaml, expand_env_vars=False)
-
-    parts = CALMImportParts(
-        flows=flows,
-        domain=domain,
+    parts = extract_calm_import_parts_from_importer(
+        importer=importer,
         config=config,
         endpoints=endpoints,
-        nlu=nlu,
     )
 
     return assistant_name, parts

rasa/utils/json_utils.py

@@ -1,6 +1,6 @@
 import json
 from decimal import Decimal
-from typing import Any, Text
+from typing import Any, Dict, List, Text
 
 
 class DecimalEncoder(json.JSONEncoder):
@@ -58,3 +58,8 @@ def replace_decimals_with_floats(obj: Any) -> Any:
         Input `obj` with all `Decimal` types replaced by `float`s.
     """
     return json.loads(json.dumps(obj, cls=DecimalEncoder))
+
+
+def extract_values(data: Dict, keys: List[Text]) -> Dict:
+    """Extracts values for given keys from a dictionary."""
+    return {key: data.get(key) for key in keys if data.get(key)}

rasa/utils/openapi.py

@@ -0,0 +1,144 @@
+from typing import Any, Dict, List, Type
+
+from pydantic.main import BaseModel
+from sanic_openapi import openapi
+from sanic_openapi.openapi3.types import Schema
+
+_SUPPORTED_ATTRIBUTES = frozenset(["format", "enum", "required", "example"])
+
+
+def _to_schema(
+    definition_stack: List[str], schema_def: Dict[str, Any], definitions: Dict[str, Any]
+) -> Schema:
+    type = schema_def.get("type")
+
+    if type == "object":
+        properties_spec = schema_def.get("properties", {})
+        properties = {}
+        for key in properties_spec:
+            properties[key] = _to_schema(
+                definition_stack=definition_stack,
+                schema_def=properties_spec[key],
+                definitions=definitions,
+            )
+        schema = openapi.Object(
+            title=schema_def.get("title"),
+            description=schema_def.get("description"),
+            required=schema_def.get("required"),
+            properties=properties,
+        )
+    elif type == "array":
+        schema = openapi.Array(
+            description=schema_def.get("description"),
+            required=schema_def.get("required"),
+            items=_to_schema(
+                definition_stack=definition_stack,
+                schema_def=schema_def.get("items"),
+                definitions=definitions,
+            ),
+        )
+    elif type is None:
+        if allof_spec := schema_def.get("allOf"):  # Model, Enum
+            definition = allof_spec[0]["$ref"].split("/")[-1]
+            definition_data = definitions.get(definition)
+            if definition_data is None:
+                schema = openapi.Object(
+                    title=definition, description=schema_def.get("description")
+                )
+            else:
+                schema = (
+                    _to_schema(
+                        definition_stack=definition_stack + [definition],
+                        schema_def={**definition_data},
+                        definitions=definitions,
+                    )
+                    if definition not in definition_stack
+                    else openapi.Object(
+                        title=definition, description=schema_def.get("description")
+                    )
+                )
+
+        elif anyof_spec := schema_def.get("anyOf"):  # Union
+            anyof = []
+            for any in anyof_spec:
+                if any.get("type"):
+                    schema_type_obj = Schema(
+                        **{
+                            "type": any.get("type"),
+                            "description": any.get("description"),
+                        }
+                    )
+                    anyof.append(schema_type_obj)
+                else:
+                    definition = any["$ref"].split("/")[-1]
+                    if definition not in definition_stack:
+                        definition_data = definitions.get(definition)
+                        if definition_data is not None:
+                            anyof.append(
+                                _to_schema(
+                                    definition_stack=definition_stack + [definition],
+                                    schema_def=definition_data,
+                                    definitions=definitions,
+                                )
+                            )
+                        else:
+                            anyof.append(
+                                openapi.Object(
+                                    title=definition,
+                                    description=schema_def.get(
+                                        "description", definition
+                                    ),
+                                    properties={},
+                                )
+                            )
+                    else:
+                        anyof.append(
+                            openapi.Object(
+                                title=definition,
+                                description=schema_def.get("description", definition),
+                                properties={},
+                            )
+                        )
+            schema = Schema(anyOf=anyof)
+        elif ref := schema_def.get("$ref"):  # $ref
+            definition = ref.split("/")[-1]
+            definition_data = definitions.get(definition)
+            if definition_data is not None:
+                schema = _to_schema(
+                    definition_stack=definition_stack,
+                    schema_def=definition_data,
+                    definitions=definitions,
+                )
+            else:
+                schema = openapi.Object(
+                    title=definition, description=schema_def.get("description")
+                )
+        else:  # Any type
+            schema = Schema(
+                **{"type": "object", "description": schema_def.get("description")}
+            )
+
+    else:
+        schema_spec = {
+            "type": schema_def.get("type"),
+            "description": schema_def.get("description"),
+        }
+        for spec in _SUPPORTED_ATTRIBUTES:
+            if schema_def.get(spec):
+                schema_spec[spec] = schema_def.get(spec)
+        schema = Schema(**schema_spec)
+
+    return schema
+
+
+def model_to_schema(model: Type[BaseModel]) -> Schema:
+    schema = model.model_json_schema()
+    # Handle both $defs (newer JSON Schema) and definitions (older JSON Schema)
+    definitions = schema.get("$defs") or schema.get("definitions") or {}
+    return _to_schema(
+        definition_stack=[],
+        schema_def=dict(
+            filter(lambda key: key[0] not in ("definitions", "$defs"), schema.items())
+        ),
+        definitions=definitions,
+    )

rasa/utils/plotting.py

@@ -99,7 +99,7 @@ def plot_confusion_matrix(
     zmax = confusion_matrix.max() if len(confusion_matrix) > 0 else 1
     plt.clf()
     if not color_map:
-        color_map = plt.cm.Blues
+        color_map = plt.cm.get_cmap("Blues")
     plt.imshow(
         confusion_matrix,
         interpolation="nearest",

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.13.1a14"
+__version__ = "3.13.1a16"