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

rasa/studio/link.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import argparse
+import datetime
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Text, Union
+
+import questionary
+import structlog
+from pydantic import BaseModel, Field
+
+import rasa.shared.utils.cli
+from rasa.constants import RASA_DIR_NAME
+from rasa.shared.utils.yaml import read_yaml_file, write_yaml
+from rasa.studio.config import StudioConfig
+from rasa.studio.upload import (
+    check_if_assistant_already_exists,
+    handle_upload,
+    is_auth_working,
+)
+
+structlogger = structlog.get_logger(__name__)
+
+_LINK_FILE_NAME: Text = "studio.yml"
+
+
+class AssistantLinkPayload(BaseModel):
+    assistant_name: Text
+    studio_url: Text
+    linked_at: Text = Field(
+        default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z"
+    )
+
+
+def _link_file(project_root: Path) -> Path:
+    """Return `<project-root>/.rasa/studio.yml`.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The path to the link file.
+    """
+    return project_root / RASA_DIR_NAME / _LINK_FILE_NAME
+
+
+def _write_link_file(
+    project_root: Path, assistant_name: Text, studio_url: Text
+) -> None:
+    """Persist assistant information inside the project.
+
+    Args:
+        project_root: The path to the project root.
+        assistant_name: The name of the assistant.
+        studio_url: The URL of the Rasa Studio instance.
+    """
+    file_path = _link_file(project_root)
+    file_path.parent.mkdir(exist_ok=True, parents=True)
+
+    payload = AssistantLinkPayload(
+        assistant_name=assistant_name,
+        studio_url=studio_url,
+    )
+    write_yaml(payload.model_dump(), file_path)
+
+
+def _read_link_file(
+    project_root: Path = Path.cwd(),
+) -> Optional[Union[List[Any], Dict[Text, Any]]]:
+    """Reads the link configuration file.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The assistant information if the file exists, otherwise None.
+    """
+    file_path = _link_file(project_root)
+    if not file_path.is_file():
+        return None
+
+    return read_yaml_file(file_path)
+
+
+def read_assistant_name(project_root: Path = Path.cwd()) -> Optional[Text]:
+    """Reads the assistant_name from the linked configuration file.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The assistant name if the file exists, otherwise None.
+    """
+    linked = _read_link_file(project_root)
+    assistant_name = (
+        linked.get("assistant_name") if linked and isinstance(linked, dict) else None
+    )
+
+    if not assistant_name:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "This project is not linked to any Rasa Studio assistant.\n"
+            "Run `rasa studio link <assistant-name>` first."
+        )
+
+    return assistant_name
+
+
+def get_studio_config() -> StudioConfig:
+    """Get the StudioConfig object or exit with an error message.
+
+    Returns:
+        A valid StudioConfig object.
+    """
+    config = StudioConfig.read_config()
+    if not config.is_valid():
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Rasa Studio is not configured correctly. Run `rasa studio config` first."
+        )
+    if not is_auth_working(config.studio_url, not config.disable_verify):
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Authentication invalid or expired. Please run `rasa studio login`."
+        )
+    return config
+
+
+def _ensure_assistant_exists(
+    assistant_name: Text,
+    studio_cfg: StudioConfig,
+    args: argparse.Namespace,
+) -> bool:
+    """Create the assistant on Studio if it does not yet exist.
+
+    Args:
+        assistant_name: The name the user provided on the CLI.
+        studio_cfg: The validated Studio configuration.
+        args: The original CLI args (needed for `handle_upload`).
+
+    Returns:
+        True if the assistant already exists or was created, False otherwise.
+    """
+    verify_ssl = not studio_cfg.disable_verify
+    assistant_already_exists = check_if_assistant_already_exists(
+        assistant_name, studio_cfg.studio_url, verify_ssl
+    )
+    if not assistant_already_exists:
+        should_create_assistant = questionary.confirm(
+            f"Assistant '{assistant_name}' was not found on Rasa Studio. "
+            f"Do you want to create it?"
+        ).ask()
+        if should_create_assistant:
+            # `handle_upload` expects the name to live in `args.assistant_name`
+            args.assistant_name = assistant_name
+            handle_upload(args)
+
+            rasa.shared.utils.cli.print_info(
+                f"Assistant {assistant_name} successfully created."
+            )
+        return should_create_assistant
+
+    return assistant_already_exists
+
+
+def handle_link(args: argparse.Namespace) -> None:
+    """Implementation of `rasa studio link <assistant-name>` CLI command.
+
+    Args:
+        args: The command line arguments.
+    """
+    assistant_name: Text = args.assistant_name[0]
+    studio_cfg = get_studio_config()
+    assistant_exists = _ensure_assistant_exists(assistant_name, studio_cfg, args)
+    if not assistant_exists:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Project has not been linked with Studio assistant."
+        )
+
+    project_root = Path.cwd()
+    link_file = _link_file(project_root)
+
+    if link_file.exists():
+        overwrite = questionary.confirm(
+            f"This project is already linked " f"(link file '{link_file}').\nOverwrite?"
+        ).ask()
+        if not overwrite:
+            rasa.shared.utils.cli.print_info(
+                "Existing link kept – nothing was changed."
+            )
+            sys.exit(0)
+
+    _write_link_file(project_root, assistant_name, studio_cfg.studio_url)
+
+    structlogger.info(
+        "studio.link.success",
+        event_info=f"Project linked to Studio assistant '{assistant_name}'.",
+        assistant_name=assistant_name,
+    )
+    rasa.shared.utils.cli.print_success(
+        f"Project successfully linked to assistant '{assistant_name}'."
+    )

rasa/studio/pull.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Text, Union
+
+import structlog
+
+import rasa.cli.utils
+import rasa.shared.utils.cli
+from rasa.shared.constants import DEFAULT_CONFIG_PATH, DEFAULT_ENDPOINTS_PATH
+from rasa.shared.utils.io import write_text_file
+from rasa.studio.data_handler import StudioDataHandler
+from rasa.studio.download.download import handle_download
+from rasa.studio.link import get_studio_config, read_assistant_name
+
+structlogger = structlog.get_logger(__name__)
+
+
+def _write_to_file(
+    content: Text, file_type: Text, file_path: Text, default_path: Text
+) -> None:
+    """Write the content to a file.
+
+    Args:
+        content: The content to write.
+        file_type: The type of file (e.g., "config" or "endpoints".).
+        file_path: The path to the file.
+        default_path: The default path to use file_path is not valid.
+    """
+    path: Union[Path, str, None] = rasa.cli.utils.get_validated_path(
+        file_path, file_type, default_path, none_is_valid=True
+    )
+    write_text_file(content, path, encoding="utf-8")
+    rasa.shared.utils.cli.print_success(f"Pulled {file_type} data from assistant.")
+
+
+def handle_pull(args: argparse.Namespace) -> None:
+    """Pull all data and overwrite the local assistant.
+
+    Args:
+        args: The parsed arguments.
+    """
+    assistant_name = read_assistant_name()
+
+    # Use the CLI command logic to download with overwrite
+    download_args = argparse.Namespace(**vars(args))
+    download_args.assistant_name = [assistant_name]
+    download_args.overwrite = True
+
+    handle_download(download_args)
+    rasa.shared.utils.cli.print_success("Pulled the data from assistant.")
+
+
+def handle_pull_config(args: argparse.Namespace) -> None:
+    """Pull just the assistant's `config.yml`.
+
+    Args:
+        args: The parsed arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    handler = StudioDataHandler(studio_cfg, assistant_name)
+    handler.request_all_data()
+
+    config_yaml = handler.get_config()
+    if not config_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No configuration data was found in the Studio assistant."
+        )
+
+    _write_to_file(config_yaml, "config", args.config, DEFAULT_CONFIG_PATH)
+
+
+def handle_pull_endpoints(args: argparse.Namespace) -> None:
+    """Pull just the assistant's `endpoints.yml`.
+
+    Args:
+        args: The parsed arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    handler = StudioDataHandler(studio_cfg, assistant_name)
+    handler.request_all_data()
+
+    endpoints_yaml = handler.get_endpoints()
+    if not endpoints_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No endpoints data was found in the Studio assistant."
+        )
+
+    _write_to_file(endpoints_yaml, "endpoints", args.endpoints, DEFAULT_ENDPOINTS_PATH)

rasa/studio/push.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Dict, Text
+
+import structlog
+
+import rasa.shared.utils.cli
+from rasa.shared.core.flows.yaml_flows_io import YamlFlowsWriter
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
+from rasa.shared.utils.io import read_file
+from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
+from rasa.studio.config import StudioConfig
+from rasa.studio.link import get_studio_config, read_assistant_name
+from rasa.studio.upload import (
+    build_import_request,
+    make_request,
+    run_validation,
+)
+
+structlogger = structlog.get_logger(__name__)
+
+
+def _send_to_studio(
+    assistant_name: Text,
+    payload_parts: Dict[Text, Text],
+    studio_cfg: StudioConfig,
+) -> None:
+    """Build the GraphQL request and send it.
+
+    Args:
+        assistant_name: The name of the assistant.
+        payload_parts: The parts of the payload to send.
+        studio_cfg: The StudioConfig object.
+    """
+    graphql_req = build_import_request(
+        assistant_name=assistant_name,
+        flows_yaml=payload_parts.get("flows"),
+        domain_yaml=payload_parts.get("domain"),
+        config_yaml=payload_parts.get("config"),
+        endpoints=payload_parts.get("endpoints"),
+        nlu_yaml=payload_parts.get("nlu"),
+    )
+    verify = not studio_cfg.disable_verify
+    result = make_request(studio_cfg.studio_url, graphql_req, verify)
+    if not result.was_successful:
+        rasa.shared.utils.cli.print_error_and_exit(result.message)
+
+    rasa.shared.utils.cli.print_success(f"Pushed data to assistant '{assistant_name}'.")
+
+
+def handle_push(args: argparse.Namespace) -> None:
+    """Push the entire assistant.
+
+    Args:
+        args: The command line arguments.
+    """
+    studio_cfg = get_studio_config()
+
+    run_validation(args)
+
+    importer = TrainingDataImporter.load_from_dict(
+        domain_path=args.domain,
+        config_path=args.config,
+        expand_env_vars=False,
+    )
+
+    domain_yaml = dump_obj_as_yaml_to_string(importer.get_user_domain().as_dict())
+    config_yaml = read_file(Path(args.config))
+    endpoints_yaml = read_file(Path(args.endpoints))
+
+    flow_importer = TrainingDataImporter.load_from_dict(
+        training_data_paths=args.data, expand_env_vars=False
+    )
+    flows_yaml = YamlFlowsWriter().dumps(flow_importer.get_user_flows())
+
+    nlu_importer = TrainingDataImporter.load_from_dict(
+        training_data_paths=args.data, expand_env_vars=False
+    )
+    nlu_yaml = RasaYAMLWriter().dumps(nlu_importer.get_nlu_data())
+
+    assistant_name = read_assistant_name()
+    _send_to_studio(
+        assistant_name,
+        {
+            "flows": flows_yaml,
+            "domain": domain_yaml,
+            "config": config_yaml,
+            "endpoints": endpoints_yaml,
+            "nlu": nlu_yaml,
+        },
+        studio_cfg,
+    )
+
+
+def handle_push_config(args: argparse.Namespace) -> None:
+    """Push only the assistant configuration (config.yml).
+
+    Args:
+        args: The command line arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    config_yaml = read_file(Path(args.config))
+    if not config_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No configuration data was found in the assistant."
+        )
+
+    _send_to_studio(assistant_name, {"config": config_yaml}, studio_cfg)
+
+
+def handle_push_endpoints(args: argparse.Namespace) -> None:
+    """Push only the endpoints configuration (endpoints.yml).
+
+    Args:
+        args: The command line arguments.
+    """
+    studio_cfg = get_studio_config()
+    assistant_name = read_assistant_name()
+
+    endpoints_yaml = read_file(Path(args.endpoints))
+    if not endpoints_yaml:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "No endpoints data was found in the assistant."
+        )
+
+    _send_to_studio(assistant_name, {"endpoints": endpoints_yaml}, studio_cfg)

rasa/studio/upload.py

@@ -2,11 +2,12 @@ import argparse
 import base64
 import re
 import sys
-from typing import Any, Dict, Iterable, List, Set, Text, Tuple, Union
+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
@@ -32,6 +33,7 @@ from rasa.shared.nlu.training_data.formats.rasa_yaml import (
 )
 from rasa.shared.utils.yaml import (
     dump_obj_as_yaml_to_string,
+    read_yaml,
     read_yaml_file,
 )
 from rasa.studio import results_logger
@@ -64,6 +66,16 @@ 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],
@@ -208,79 +220,93 @@ def _get_assistant_name(config: Dict[Text, Any]) -> str:
     return assistant_name
 
 
-@with_studio_error_handler
-def upload_calm_assistant(
-    args: argparse.Namespace, endpoint: str, verify: bool = True
-) -> StudioResult:
-    """Validates and uploads the CALM assistant data to Rasa Studio.
+def build_calm_import_parts(
+    data_path: Union[Text, List[Text]],
+    domain_path: Text,
+    config_path: Text,
+    endpoints_path: Optional[Text] = None,
+    assistant_name: Optional[Text] = None,
+) -> Tuple[str, CALMImportParts]:
+    """Builds the parts of the assistant to be uploaded to Studio.
 
     Args:
-        args: The command line arguments
-            - data: The path to the training data
-            - domain: The path to the domain
-            - flows: The path to the flows
-            - endpoints: The path to the endpoints
-            - config: The path to the config
-        endpoint: The studio endpoint
-        verify: Whether to verify SSL
+        data_path: The path to the training data
+        domain_path: The path to the domain
+        config_path: The path to the config
+        endpoints_path: The path to the endpoints
+        assistant_name: The name of the assistant
+
     Returns:
-        None
+        The assistant name and the parts to be uploaded
     """
-    run_validation(args)
-
-    structlogger.info(
-        "rasa.studio.upload.loading_data", event_info="Parsing CALM assistant data..."
-    )
-
     importer = TrainingDataImporter.load_from_dict(
-        domain_path=args.domain,
-        config_path=args.config,
+        domain_path=domain_path,
+        config_path=config_path,
         expand_env_vars=False,
     )
 
-    # Prepare config and domain
-    config = importer.get_config()
-    assistant_name = _get_assistant_name(config)
+    config = read_yaml_file(config_path, expand_env_vars=False)
+    endpoints = read_yaml_file(endpoints_path, expand_env_vars=False)
+    assistant_name = assistant_name or _get_assistant_name(config)
 
-    config_from_files = read_yaml_file(args.config, expand_env_vars=False)
     domain_from_files = importer.get_user_domain().as_dict()
-
-    # Extract domain and config values
     domain = extract_values(domain_from_files, DOMAIN_KEYS)
 
-    # Prepare flows
     flow_importer = FlowSyncImporter.load_from_dict(
-        training_data_paths=args.data, expand_env_vars=False
+        training_data_paths=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)
 
-    # We instantiate the TrainingDataImporter again on purpose to avoid
-    # adding patterns to domain's actions. More info https://t.ly/W8uuc
     nlu_importer = TrainingDataImporter.load_from_dict(
-        training_data_paths=args.data, expand_env_vars=False
+        training_data_paths=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,
+        config=config,
+        endpoints=endpoints,
+        nlu=nlu,
+    )
+
+    return assistant_name, parts
+
+
+@with_studio_error_handler
+def upload_calm_assistant(
+    args: argparse.Namespace, endpoint: str, verify: bool = True
+) -> StudioResult:
+    def yaml_or_empty(part: Dict[Text, Any]) -> Optional[str]:
+        return dump_obj_as_yaml_to_string(part) if part else None
 
-    # Prepare endpoints
-    endpoints_from_files = read_yaml_file(args.endpoints, expand_env_vars=False)
-    endpoints_str = dump_obj_as_yaml_to_string(
-        endpoints_from_files, transform=remove_quotes
+    run_validation(args)
+    structlogger.info(
+        "rasa.studio.upload.loading_data", event_info="Parsing CALM assistant data..."
+    )
+    assistant_name, parts = build_calm_import_parts(
+        data_path=args.data,
+        domain_path=args.domain,
+        config_path=args.config,
+        endpoints_path=args.endpoints,
     )
 
-    # Build GraphQL request
     graphql_req = build_import_request(
         assistant_name,
-        flows_yaml=YamlFlowsWriter().dumps(flows),
-        domain_yaml=dump_obj_as_yaml_to_string(domain),
-        config_yaml=dump_obj_as_yaml_to_string(config_from_files),
-        endpoints=endpoints_str,
-        nlu_yaml=nlu_examples_yaml,
+        flows_yaml=yaml_or_empty(parts.flows),
+        domain_yaml=yaml_or_empty(parts.domain),
+        config_yaml=yaml_or_empty(parts.config),
+        endpoints=yaml_or_empty(parts.endpoints),
+        nlu_yaml=yaml_or_empty(parts.nlu),
     )
-
     structlogger.info(
         "rasa.studio.upload.calm", event_info="Uploading to Rasa Studio..."
     )
@@ -393,7 +419,6 @@ def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> Studi
         },
         verify=verify,
     )
-
     if results_logger.response_has_errors(res.json()):
         track_upload_to_studio_failed(res.json())
         return StudioResult.error(res.json())
@@ -421,39 +446,64 @@ def _add_missing_entities(
 
 def build_import_request(
     assistant_name: str,
-    flows_yaml: str,
-    domain_yaml: str,
-    config_yaml: str,
-    endpoints: str,
-    nlu_yaml: str = "",
+    flows_yaml: Optional[str] = None,
+    domain_yaml: Optional[str] = None,
+    config_yaml: Optional[str] = None,
+    endpoints: Optional[str] = None,
+    nlu_yaml: Optional[str] = None,
 ) -> Dict:
-    # b64encode expects bytes and returns bytes so we need to decode to string
-    base64_domain = base64.b64encode(domain_yaml.encode("utf-8")).decode("utf-8")
-    base64_flows = base64.b64encode(flows_yaml.encode("utf-8")).decode("utf-8")
-    base64_config = base64.b64encode(config_yaml.encode("utf-8")).decode("utf-8")
-    base64_nlu = base64.b64encode(nlu_yaml.encode("utf-8")).decode("utf-8")
-    base64_endpoints = base64.b64encode(endpoints.encode("utf-8")).decode("utf-8")
+    """Builds the GraphQL request for uploading a modern assistant.
+
+    Args:
+        assistant_name: The name of the assistant
+        flows_yaml: The YAML representation of the flows
+        domain_yaml: The YAML representation of the domain
+        config_yaml: The YAML representation of the config
+        endpoints: The YAML representation of the endpoints
+        nlu_yaml: The YAML representation of the NLU data
+
+    Returns:
+        A dictionary representing the GraphQL request for uploading the assistant.
+    """
+    inputs_map = {
+        "domain": domain_yaml,
+        "flows": flows_yaml,
+        "config": config_yaml,
+        "endpoints": endpoints,
+        "nlu": nlu_yaml,
+    }
+
+    payload = {
+        field: convert_string_to_base64(value)
+        for field, value in inputs_map.items()
+        if value is not None
+    }
+
+    variables_input = {"assistantName": assistant_name, **payload}
 
     graphql_req = {
         "query": (
             "mutation UploadModernAssistant($input: UploadModernAssistantInput!)"
             "{\n  uploadModernAssistant(input: $input)\n}"
         ),
-        "variables": {
-            "input": {
-                "assistantName": assistant_name,
-                "domain": base64_domain,
-                "flows": base64_flows,
-                "nlu": base64_nlu,
-                "config": base64_config,
-                "endpoints": base64_endpoints,
-            }
-        },
+        "variables": {"input": variables_input},
     }
 
     return graphql_req
 
 
+def convert_string_to_base64(string: str) -> str:
+    """Converts a string to base64.
+
+    Args:
+        string: The string to convert
+
+    Returns:
+        The base64 encoded string
+    """
+    return base64.b64encode(string.encode("utf-8")).decode("utf-8")
+
+
 def build_request(
     assistant_name: str, nlu_examples_yaml: str, domain_yaml: str
 ) -> Dict: