rasa-pro 3.11.0__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

rasa/studio/data_handler.py

@@ -76,9 +76,7 @@ class StudioDataHandler:
 
         return request
 
-    def _make_request(
-        self, GQL_req: Dict[Any, Any], verify: bool = True
-    ) -> Dict[Any, Any]:
+    def _make_request(self, GQL_req: Dict[Any, Any]) -> Dict[Any, Any]:
         token = KeycloakTokenReader().get_token()
         if token.is_expired():
             token = self.refresh_token(token)
@@ -95,7 +93,6 @@ class StudioDataHandler:
                 "Authorization": f"{token.token_type} {token.access_token}",
                 "Content-Type": "application/json",
             },
-            verify=verify,
         )
 
         if res.status_code != 200:
@@ -131,9 +128,7 @@ class StudioDataHandler:
             The data from Rasa Studio.
         """
         GQL_req = self._build_request()
-        verify = not self.studio_config.disable_verify
-
-        response = self._make_request(GQL_req, verify=verify)
+        response = self._make_request(GQL_req)
         self._extract_data(response)
 
     def request_data(
@@ -150,9 +145,7 @@ class StudioDataHandler:
             The data from Rasa Studio.
         """
         GQL_req = self._build_request(intent_names, entity_names)
-        verify = not self.studio_config.disable_verify
-
-        response = self._make_request(GQL_req, verify=verify)
+        response = self._make_request(GQL_req)
         self._extract_data(response)
 
     def get_config(self) -> Optional[str]:
@@ -360,9 +353,7 @@ def import_data_from_studio(
     studio_domain.persist(domain_file)
 
     data_from_studio = TrainingDataImporter.load_from_dict(
-        domain_path=str(domain_file),
-        training_data_paths=data_paths,
-        expand_env_vars=False,
+        domain_path=str(domain_file), training_data_paths=data_paths
     )
 
     return data_from_studio, data_original

rasa/studio/upload.py

@@ -15,18 +15,11 @@ from rasa.shared.constants import (
     DEFAULT_DOMAIN_PATHS,
     DEFAULT_CONFIG_PATH,
 )
-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 YamlFlowsWriter
 from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter, FlowSyncImporter
-from rasa.shared.nlu.training_data.formats.rasa_yaml import (
-    RasaYAMLReader,
-    RasaYAMLWriter,
-)
-from rasa.shared.utils.yaml import (
-    dump_obj_as_yaml_to_string,
-    read_yaml_file,
-)
+from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
+from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string, read_yaml_file
 from rasa.studio import results_logger
 from rasa.studio.auth import KeycloakTokenReader
 from rasa.studio.config import StudioConfig
@@ -34,27 +27,6 @@ from rasa.studio.results_logger import StudioResult, with_studio_error_handler
 
 structlogger = structlog.get_logger()
 
-CONFIG_KEYS = [
-    "recipe",
-    "language",
-    "pipeline",
-    "llm",
-    "policies",
-    "model_name",
-    "assistant_id",
-]
-
-DOMAIN_KEYS = [
-    "version",
-    "actions",
-    "responses",
-    "slots",
-    "intents",
-    "entities",
-    "forms",
-    "session_config",
-]
-
 
 def _get_selected_entities_and_intents(
     args: argparse.Namespace,
@@ -82,81 +54,42 @@ def _get_selected_entities_and_intents(
     return list(entities), list(intents)
 
 
-def run_validation(args: argparse.Namespace) -> None:
-    """Run the validation before uploading to Studio.
-
-    This is to avoid uploading invalid assistant data
-    that would raise errors during Rasa Pro training in Studio.
-
-    The validation checks that were selected to be run before uploading
-    maintain parity with the features that are supported in Studio.
-    """
-    from rasa.validator import Validator
-
-    training_data_importer = TrainingDataImporter.load_from_dict(
-        domain_path=args.domain,
-        training_data_paths=args.data,
-        config_path=args.config,
-        expand_env_vars=False,
-    )
-
-    structlogger.info(
-        "rasa.studio.upload.validating_data",
-        event_info="Validating domain and training data...",
-    )
-
-    validator = Validator.from_importer(training_data_importer)
-
-    if not validator.verify_studio_supported_validations():
-        structlogger.error(
-            "rasa.studio.upload.validate_files.project_validation_error",
-            event_info="Project validation completed with errors.",
-        )
-        sys.exit(1)
-
-    structlogger.info(
-        "rasa.studio.upload.validate_files.success",
-        event_info="Project validation completed successfully.",
-    )
-
-
 def handle_upload(args: argparse.Namespace) -> None:
     """Uploads primitives to rasa studio."""
-    studio_config = StudioConfig.read_config()
-    endpoint = studio_config.studio_url
-    verify = not studio_config.disable_verify
-
+    endpoint = StudioConfig.read_config().studio_url
     if not endpoint:
         rasa.shared.utils.cli.print_error_and_exit(
             "No GraphQL endpoint found in config. Please run `rasa studio config`."
         )
-        return
-
-    if not is_auth_working(endpoint, verify):
-        rasa.shared.utils.cli.print_error_and_exit(
-            "Authentication is invalid or expired. Please run `rasa studio login`."
+    else:
+        structlogger.info(
+            "rasa.studio.upload.loading_data", event_info="Loading data..."
         )
-        return
 
-    structlogger.info("rasa.studio.upload.loading_data", event_info="Loading data...")
+        args.domain = rasa.cli.utils.get_validated_path(
+            args.domain, "domain", DEFAULT_DOMAIN_PATHS
+        )
 
-    args.domain = rasa.cli.utils.get_validated_path(
-        args.domain, "domain", DEFAULT_DOMAIN_PATHS
-    )
+        args.config = rasa.cli.utils.get_validated_path(
+            args.config, "config", DEFAULT_CONFIG_PATH
+        )
 
-    args.config = rasa.cli.utils.get_validated_path(
-        args.config, "config", DEFAULT_CONFIG_PATH
-    )
+        # check safely if args.calm is set and not fail if not
+        if hasattr(args, "calm") and args.calm:
+            upload_calm_assistant(args, endpoint)
+        else:
+            upload_nlu_assistant(args, endpoint)
 
-    Domain.expand_env_vars = False
-    RasaYAMLReader.expand_env_vars = False
-    YAMLFlowsReader.expand_env_vars = False
 
-    # check safely if args.calm is set and not fail if not
-    if hasattr(args, "calm") and args.calm:
-        upload_calm_assistant(args, endpoint, verify=verify)
-    else:
-        upload_nlu_assistant(args, endpoint, verify=verify)
+config_keys = [
+    "recipe",
+    "language",
+    "pipeline",
+    "llm",
+    "policies",
+    "model_name",
+    "assistant_id",
+]
 
 
 def extract_values(data: Dict, keys: List[Text]) -> Dict:
@@ -188,19 +121,13 @@ def _get_assistant_name(config: Dict[Text, Any]) -> str:
             ),
         )
 
-    structlogger.info(
-        "rasa.studio.upload.name_selected",
-        event_info=f"Uploading assistant with the name '{assistant_name}'.",
-        assistant_name=assistant_name,
-    )
+    structlogger.info(f"Uploading assistant with the name '{assistant_name}'.")
     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 upload_calm_assistant(args: argparse.Namespace, endpoint: str) -> StudioResult:
+    """Uploads the CALM assistant data to Rasa Studio.
 
     Args:
         args: The command line arguments
@@ -213,8 +140,6 @@ def upload_calm_assistant(
     Returns:
         None
     """
-    run_validation(args)
-
     structlogger.info(
         "rasa.studio.upload.loading_data", event_info="Parsing CALM assistant data..."
     )
@@ -222,36 +147,63 @@ def upload_calm_assistant(
     importer = TrainingDataImporter.load_from_dict(
         domain_path=args.domain,
         config_path=args.config,
-        expand_env_vars=False,
     )
 
     # Prepare config and domain
     config = importer.get_config()
     domain_from_files = importer.get_user_domain().as_dict()
-    endpoints_from_files = read_yaml_file(args.endpoints, expand_env_vars=False)
-    config_from_files = read_yaml_file(args.config, expand_env_vars=False)
+    endpoints_from_files = read_yaml_file(args.endpoints)
+    config_from_files = read_yaml_file(args.config)
 
     # Extract domain and config values
-    domain = extract_values(domain_from_files, DOMAIN_KEYS)
+    domain_keys = [
+        "version",
+        "actions",
+        "responses",
+        "slots",
+        "intents",
+        "entities",
+        "forms",
+        "session_config",
+    ]
+
+    domain = extract_values(domain_from_files, domain_keys)
+
+    assistant_name = _get_assistant_name(config)
+
+    training_data_paths = args.data
+
+    if isinstance(training_data_paths, list):
+        training_data_paths.append(args.flows)
+    elif isinstance(training_data_paths, str):
+        if isinstance(args.flows, list):
+            training_data_paths = [training_data_paths] + args.flows
+        elif isinstance(args.flows, str):
+            training_data_paths = [training_data_paths, args.flows]
+        else:
+            raise RasaException("Invalid flows path")
 
     # Prepare flows
     flow_importer = FlowSyncImporter.load_from_dict(
-        training_data_paths=args.data, expand_env_vars=False
+        training_data_paths=training_data_paths
     )
+
     flows = list(flow_importer.get_user_flows())
 
     # 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
+        domain_path=args.domain, training_data_paths=args.data
     )
     nlu_data = nlu_importer.get_nlu_data()
+
+    intents_from_files = nlu_data.intents
+
     nlu_examples = nlu_data.filter_training_examples(
-        lambda ex: ex.get("intent") in nlu_data.intents
+        lambda ex: ex.get("intent") in intents_from_files
     )
-    nlu_examples_yaml = RasaYAMLWriter().dumps(nlu_examples)
 
-    assistant_name = _get_assistant_name(config)
+    nlu_examples_yaml = RasaYAMLWriter().dumps(nlu_examples)
 
     # Build GraphQL request
     graphql_req = build_import_request(
@@ -263,16 +215,12 @@ def upload_calm_assistant(
         nlu_yaml=nlu_examples_yaml,
     )
 
-    structlogger.info(
-        "rasa.studio.upload.calm", event_info="Uploading to Rasa Studio..."
-    )
-    return make_request(endpoint, graphql_req, verify)
+    structlogger.info("Uploading to Rasa Studio...")
+    return make_request(endpoint, graphql_req)
 
 
 @with_studio_error_handler
-def upload_nlu_assistant(
-    args: argparse.Namespace, endpoint: str, verify: bool = True
-) -> StudioResult:
+def upload_nlu_assistant(args: argparse.Namespace, endpoint: str) -> StudioResult:
     """Uploads the classic (dm1) assistant data to Rasa Studio.
 
     Args:
@@ -282,37 +230,27 @@ def upload_nlu_assistant(
             - intents: The intents to upload
             - entities: The entities to upload
         endpoint: The studio endpoint
-        verify: Whether to verify SSL
     Returns:
         None
     """
-    structlogger.info(
-        "rasa.studio.upload.nlu_data_read",
-        event_info="Found DM1 assistant data, parsing...",
-    )
+    structlogger.info("Found DM1 assistant data, parsing...")
     importer = TrainingDataImporter.load_from_dict(
-        domain_path=args.domain,
-        training_data_paths=args.data,
-        config_path=args.config,
-        expand_env_vars=False,
+        domain_path=args.domain, training_data_paths=args.data, config_path=args.config
     )
 
     intents_from_files = importer.get_nlu_data().intents
+    entities_from_files = importer.get_domain().entities
 
-    domain_from_files = importer.get_domain()
-    entities_from_files = domain_from_files.entities
     entities, intents = _get_selected_entities_and_intents(
         args, intents_from_files, entities_from_files
     )
 
     config_from_files = importer.get_config()
-    config = extract_values(config_from_files, CONFIG_KEYS)
+    config = extract_values(config_from_files, config_keys)
 
     assistant_name = _get_assistant_name(config)
 
-    structlogger.info(
-        "rasa.studio.upload.nlu_data_validate", event_info="Validating data..."
-    )
+    structlogger.info("Validating data...")
     _check_for_missing_primitives(
         intents, entities, intents_from_files, entities_from_files
     )
@@ -324,46 +262,21 @@ def upload_nlu_assistant(
     all_entities = _add_missing_entities(nlu_examples.entities, entities)
     nlu_examples_yaml = RasaYAMLWriter().dumps(nlu_examples)
 
-    domain = _filter_domain(all_entities, intents, domain_from_files.as_dict())
+    domain = _filter_domain(all_entities, intents, importer.get_domain().as_dict())
     domain_yaml = dump_obj_as_yaml_to_string(domain)
 
     graphql_req = build_request(assistant_name, nlu_examples_yaml, domain_yaml)
 
-    structlogger.info(
-        "rasa.studio.upload.nlu", event_info="Uploading to Rasa Studio..."
-    )
-    return make_request(endpoint, graphql_req, verify)
-
-
-def is_auth_working(endpoint: str, verify: bool = True) -> bool:
-    """Send a test request to Studio to check if auth is working."""
-    result = make_request(
-        endpoint,
-        {
-            "operationName": "LicenseDetails",
-            "query": (
-                "query LicenseDetails {\n"
-                "  licenseDetails {\n"
-                "    valid\n"
-                "    scopes\n"
-                "    __typename\n"
-                "  }\n"
-                "}"
-            ),
-            "variables": {},
-        },
-        verify,
-    )
-    return result.was_successful
+    structlogger.info("Uploading to Rasa Studio...")
+    return make_request(endpoint, graphql_req)
 
 
-def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> StudioResult:
+def make_request(endpoint: str, graphql_req: Dict) -> StudioResult:
     """Makes a request to the studio endpoint to upload data.
 
     Args:
         endpoint: The studio endpoint
         graphql_req: The graphql request
-        verify: Whether to verify SSL
     """
     token = KeycloakTokenReader().get_token()
     res = requests.post(
@@ -373,7 +286,6 @@ def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> Studi
             "Authorization": f"{token.token_type} {token.access_token}",
             "Content-Type": "application/json",
         },
-        verify=verify,
     )
 
     if results_logger.response_has_errors(res.json()):
@@ -389,12 +301,7 @@ def _add_missing_entities(
     for entity in entities_from_intents:
         if entity not in entities:
             structlogger.warning(
-                "rasa.studio.upload.adding_missing_entity",
-                event_info=(
-                    f"Adding entity '{entity}' to upload "
-                    "since it is used in an intent."
-                ),
-                entity=entity,
+                f"Adding entity '{entity}' to upload since it is used in an intent."
             )
             all_entities.append(entity)
     return all_entities
@@ -462,9 +369,7 @@ def build_request(
 
 
 def _filter_domain(
-    entities: List[Union[str, Dict]],
-    intents: List[str],
-    domain_from_files: Dict[str, Any],
+    entities: List[Union[str, Dict]], intents: List[str], domain_from_files: Dict
 ) -> Dict:
     """Filters the domain to only include the selected entities and intents."""
     selected_entities = _remove_not_selected_entities(