rasa-pro 3.8.16__py3-none-any.whl

rasa/utils/licensing.py

@@ -0,0 +1,319 @@
+import hashlib
+import logging
+import os
+import re
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict, Optional, Set, Text
+
+import jwt
+from dotenv import dotenv_values
+
+LICENSE_ENV_VAR = "RASA_PRO_LICENSE"
+ALGORITHM = "RS256"
+# deepcode ignore HardcodedKey: This is a public key - not a security issue.
+PUBLIC_KEY = """-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6L90HBMIeiEUkLw85aRx
+L8qisVwiJwy3E4E/MPKHEuzguUJG3KwQE3Yb37HWi6I8EXOI5UfP2RvbNPKbmYFo
+90P27rKpvhZRCG9sy3cNu3Xr1XcQ6Eue2e12LWBAgzBZSqjzwkCOtt+L6LIm3lPf
+2QYSFORTZR9PtOvI1b677W1lVjioRrbg1IG6UXGVOTCmeSFT/JzbsYzR7QFzFdWe
+ytjHVgeb/R9inY1/LeiP2KCHYcYUF2sGc+6CsGvr9Kkio5KS10jBF27EeBaeVpXO
+JH5viXVuRPCu5ymvnih5Rk4VYK3X3rG1rf5oju9OBDPLq7lKklY1pPZjBHADPU3o
+/QIDAQAB
+-----END PUBLIC KEY-----"""
+
+# If a license must be revoked before expiration, add its JTI to this list.
+# Adding to this list requires cutting a new release for the change to affect users.
+# Versions prior to the one including the blocked JTI will still
+# be available to blocked users until the regular expiration date
+JTI_BLOCKLIST: Set[Text] = set([])
+
+SCOPE_DELIMITER = ":"
+PRODUCT_AREA = "rasa:pro:plus"
+VOICE_SCOPE = "rasa:voice"
+
+logger = logging.getLogger(__name__)
+
+
+class LicenseValidationException(Exception):
+    """Parent class for exceptions raised when handling licenses."""
+
+
+class LicenseSchemaException(LicenseValidationException):
+    """Exception raised when a license does not contain the correct fields."""
+
+
+class LicenseScopeException(LicenseValidationException):
+    """Exception raised when a license does not contain the correct scope."""
+
+
+class LicenseEncodingException(LicenseValidationException):
+    """Exception raised when the JWT representing a license is not well-formed."""
+
+
+class LicenseSignatureInvalidException(LicenseValidationException):
+    """Exception raised when a license signature could not be verified."""
+
+
+class LicenseExpiredException(LicenseValidationException):
+    """Exception raised when a license has expired (exp)."""
+
+
+class LicenseNotYetValidException(LicenseValidationException):
+    """Exception raised when a license is not valid yet (nbf)."""
+
+
+class License:
+    """Represents a Rasa Pro license.
+
+    There a are two ways of instancing an `License` object:
+    - Via `decode`: This is the option that should be used 99% of the times.
+      This option allows callers to decode a JWT into an `License`
+      object, which means that only correctly signed JWT will be decodable.
+      Other checks will be performed on the JWT as well. This implies that any
+      `License` obtained via `decode` is guaranteed to represent a
+      valid license, that is, a license that was obtained via a
+      contract/deal/etc. with Rasa Inc (i.e. the owner of the private key).
+    - Via `__init__`: This creates an `License` object directly, without
+      performing any validations. Useful only for creating new licenses (which
+      requires access to the private key to then encode) or for testing
+      purposes.
+
+    """
+
+    __slots__ = ["jti", "iat", "nbf", "scope", "exp", "email", "company"]
+
+    def __init__(
+        self,
+        *,
+        company: Text,
+        email: Text,
+        exp: int,
+        scope: Text,
+        jti: Optional[Text] = None,
+        iat: Optional[int] = None,
+        nbf: Optional[int] = None,
+    ) -> None:
+        """Initializes an instance of `License`.
+
+        Args:
+            company: Company this license is issued to.
+            email: Contact email for this license.
+            exp: Expiration date (UNIX epoch time).
+            scope: The license scope
+            jti: JWT unique identifier - a unique identifier for this
+                license. Defaults to a UUID4 if not set.
+            iat: Created at (UNIX epoch time).
+                Defaults to current time if not set.
+            nbf: Time at which the license starts being valid (UNIX epoch time).
+                Defaults to current time if not set.
+        """
+        self.company = company
+        self.email = email
+        self.exp = exp
+        self.jti = jti or str(uuid.uuid4())
+        self.iat = iat or int(time.time())
+        self.nbf = nbf or self.iat
+        self.scope = scope
+
+    def as_dict(self) -> Dict[Text, Any]:
+        """Returns this license as a dictionary object.
+
+        Returns:
+            License represented using a `dict`.
+        """
+        return {attr: getattr(self, attr) for attr in License.__slots__}
+
+    def __str__(self) -> Text:
+        """Returns a text representation of this license.
+
+        Returns:
+            String representing this license.
+        """
+        return f"License <{self.as_dict()}>"
+
+    @staticmethod
+    def decode(
+        encoded_license: Text,
+        check_not_before: Optional[bool] = True,
+        check_expiration: Optional[bool] = True,
+        product_area: Text = PRODUCT_AREA,
+    ) -> "License":
+        """Returns an instance of `License` from an encoded JWT.
+
+        Args:
+            encoded_license: JWT in encoded form.
+            check_not_before: Check if not_before is in the future.
+            check_expiration: Check if token has expired.
+            product_area: The product scope of the license.
+
+        Raises:
+            LicenseSignatureInvalidException: If the license signature could
+                not be validated.
+            LicenseNotYetValidException: If the license is not valid yet.
+            LicenseExpiredException: If the license has expired, or has been
+                blocklisted.
+            LicenseEncodingException: If the JWT was not correctly encoded.
+            LicenseSchemaException: If the license contains unknown or extra
+                fields, or if it is missing fields.
+
+        Returns:
+            A validated enterprise license.
+        """
+        try:
+            decoded = jwt.decode(
+                encoded_license,
+                key=PUBLIC_KEY,
+                algorithms=[ALGORITHM],
+                options={
+                    "verify_nbf": check_not_before,
+                    "verify_exp": check_expiration,
+                },
+            )
+        except jwt.exceptions.InvalidSignatureError:
+            raise LicenseSignatureInvalidException(
+                "Could not verify the license's signature."
+            )
+        except jwt.exceptions.ImmatureSignatureError:
+            raise LicenseNotYetValidException("The license is not valid yet (nbf).")
+        except jwt.exceptions.ExpiredSignatureError:
+            raise LicenseExpiredException("The license has already expired (exp).")
+        except jwt.exceptions.DecodeError:
+            # Handle `DecodeError` last since other more specific exceptions
+            # such as `InvalidSignatureError` inherit from it.
+            raise LicenseEncodingException("Could not decode license as JWT.")
+
+        if set(decoded.keys()) != set(License.__slots__):
+            raise LicenseSchemaException("Invalid license schema.")
+
+        license_scope = decoded.get("scope", "")
+        if not is_valid_license_scope(product_area, license_scope):
+            raise LicenseScopeException(
+                f"The product scope of your issued license does not "
+                f"include {product_area}."
+            )
+
+        if decoded["jti"] in JTI_BLOCKLIST:
+            raise LicenseExpiredException("The license has already expired.")
+
+        return License(**decoded)
+
+    def encode(self, private_key: Text) -> Text:
+        """Encodes this license into a JWT.
+
+        NOTE: This method is only useful in the context of testing, or when
+        using administrative scripts such as `license.py`. It
+        should not be used otherwise.
+
+        Args:
+            private_key: Private key to use. Should correspond to `PUBLIC_KEY`.
+
+        Returns:
+            Encoded license.
+        """
+        return jwt.encode(self.as_dict(), key=private_key, algorithm=ALGORITHM)
+
+
+def date_as_unix_timestamp(utc_date: Text) -> int:
+    """Returns a date represented as a UNIX timestamp.
+
+    Args:
+        utc_date: Date as text (YYYY-MM-DD), UTC timezone.
+
+    Returns:
+        Date as UNIX timestamp.
+    """
+    dt = datetime.strptime(utc_date, "%Y-%m-%d")
+    return int(dt.replace(tzinfo=timezone.utc).timestamp())
+
+
+def retrieve_license_from_env() -> Text:
+    """Return the license found in the env var."""
+    stored_env_values = dotenv_values(".env")
+    license_from_env = os.environ.get(LICENSE_ENV_VAR)
+    license = license_from_env or stored_env_values.get(LICENSE_ENV_VAR)
+    if not license:
+        raise SystemExit(
+            f"A Rasa Pro license is required. "
+            f"Please set the environmental variable "
+            f"`{LICENSE_ENV_VAR}` to a valid license string. "
+        )
+    return license
+
+
+def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
+    license = retrieve_license_from_env()
+    try:
+        License.decode(license, product_area=product_area)
+    except LicenseValidationException as e:
+        logger.error(e)
+        raise SystemExit(
+            f"Failed to validate Rasa Pro license "
+            f"which was read from environmental variable `{LICENSE_ENV_VAR}`. "
+            f"Please ensure `{LICENSE_ENV_VAR}` is set to a valid license string. "
+        )
+
+
+def is_valid_license_scope(product_area: Text, license_scope: Text) -> bool:
+    """Verifies that the license scope matches the rasa-plus product area."""
+    required_scopes = derive_scope_hierarchy(product_area)
+    licensed_product_areas = derive_scope_hierarchy(license_scope)
+
+    # update scopes that are required but not present in the license scope
+    required_scopes.difference_update(licensed_product_areas)
+
+    # this is dependent on a format where each product area is separated
+    # by whitespace in the license scope field value
+    licensed_scopes = license_scope.split()
+
+    # initialise a variable to count matches of
+    # licensed sub product scope pattern found in the required scopes set
+    sub_product_scope_match_count = 0
+
+    for required in required_scopes:
+        for licensed in licensed_scopes:
+            if re.search(licensed, required) is not None:
+                sub_product_scope_match_count += 1
+
+    return sub_product_scope_match_count == len(required_scopes)
+
+
+def derive_scope_hierarchy(scope: Text) -> Set[Text]:
+    """Derives all upper levels of the specified scopes and adds to a resulting set.
+
+    For example, the `rasa:pro:plus` scope would result in the following set:
+    {rasa, rasa:pro, rasa:pro:plus}.
+    """
+    product_hierarchy = [area.split(SCOPE_DELIMITER) for area in scope.split()]
+    required_scopes = [
+        SCOPE_DELIMITER.join(hierarchy[0:end])
+        for hierarchy in product_hierarchy
+        for end in range(1, len(hierarchy) + 1)
+    ]
+
+    return set(required_scopes)
+
+
+def property_of_active_license(prop: Callable[[License], str]) -> Optional[str]:
+    """Return a property for this installation based on license.
+
+    Returns:
+    The property of the license if it exists, otherwise None.
+    """
+    retrieved_license = os.environ.get(LICENSE_ENV_VAR)
+    if not retrieved_license:
+        return None
+
+    try:
+        decoded = License.decode(retrieved_license)
+        return prop(decoded)
+    except LicenseValidationException as e:
+        logger.warning("The provided license is invalid.", exc_info=e)
+        return None
+
+
+def get_license_hash() -> Optional[Text]:
+    """Return the hash of the current active license."""
+    license_value = retrieve_license_from_env()
+    return hashlib.sha256(license_value.encode("utf-8")).hexdigest()

rasa/utils/log_utils.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+import os
+import logging
+import sys
+from typing import Any, Dict, Optional
+
+import structlog
+from structlog_sentry import SentryProcessor
+from structlog.dev import ConsoleRenderer
+from structlog.typing import EventDict, WrappedLogger
+from rasa.shared.constants import (
+    ENV_LOG_LEVEL,
+    DEFAULT_LOG_LEVEL,
+    ENV_LOG_LEVEL_LLM,
+    ENV_LOG_LEVEL_LLM_MODULE_NAMES,
+    DEFAULT_LOG_LEVEL_LLM,
+)
+from rasa.plugin import plugin_manager
+
+
+FORCE_JSON_LOGGING = os.environ.get("FORCE_JSON_LOGGING")
+
+
+class HumanConsoleRenderer(ConsoleRenderer):
+    """Console renderer that outputs human-readable logs."""
+
+    def __call__(self, logger: WrappedLogger, name: str, event_dict: EventDict) -> str:
+        if "event_info" in event_dict:
+            event_key = event_dict["event"]
+            event_dict["event"] = event_dict["event_info"]
+            event_dict["event_key"] = event_key
+            del event_dict["event_info"]
+
+        return super().__call__(logger, name, event_dict)
+
+
+def _anonymizer(
+    _: structlog.BoundLogger, __: str, event_dict: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Anonymizes event dict."""
+    anonymizable_keys = [
+        "text",
+        "response_text",
+        "user_text",
+        "slots",
+        "parse_data_text",
+        "parse_data_entities",
+        "prediction_events",
+        "tracker_latest_message",
+        "prefilled_slots",
+        "message",
+        "response",
+        "slot_candidates",
+        "rasa_event",
+        "rasa_events",
+        "tracker_states",
+        "current_states",
+        "old_states",
+        "current_states",
+        "successes",
+        "current_entity",
+        "next_entity",
+        "states",
+        "entity",
+        "token_text",
+        "user_message",
+        "json_message",
+    ]
+    anonymization_pipeline = plugin_manager().hook.get_anonymization_pipeline()
+
+    if anonymization_pipeline:
+        for key in anonymizable_keys:
+            if key in event_dict:
+                anonymized_value = anonymization_pipeline.log_run(event_dict[key])
+                event_dict[key] = anonymized_value
+    return event_dict
+
+
+def configure_structlog(
+    log_level: Optional[int] = None,
+) -> None:
+    """Configure logging of the server."""
+    if log_level is None:  # Log level NOTSET is 0 so we use `is None` here
+        log_level_name = os.environ.get(ENV_LOG_LEVEL, DEFAULT_LOG_LEVEL)
+        # Change log level from str to int (note that log_level in function parameter
+        # int already, coming from CLI argparse parameter).
+        log_level = logging.getLevelName(log_level_name)
+
+    logging.basicConfig(
+        format="%(message)s",
+        stream=sys.stdout,
+        level=log_level,
+    )
+
+    shared_processors = [
+        _anonymizer,
+        # Processors that have nothing to do with output,
+        # e.g., add timestamps or log level names.
+        # If log level is too low, abort pipeline and throw away log entry.
+        structlog.stdlib.filter_by_level,
+        structlog.contextvars.merge_contextvars,
+        # Add the name of the logger to event dict.
+        # structlog.stdlib.add_logger_name,
+        # Add log level to event dict.
+        structlog.processors.add_log_level,
+        # If the "stack_info" key in the event dict is true, remove it and
+        # render the current stack trace in the "stack" key.
+        structlog.processors.StackInfoRenderer(),
+        # If some value is in bytes, decode it to a unicode str.
+        structlog.processors.UnicodeDecoder(),
+        structlog.dev.set_exc_info,
+        # add structlog sentry integration. only log fatal log entries
+        # as events as we are tracking exceptions anyways
+        SentryProcessor(event_level=logging.FATAL),
+    ]
+
+    if not FORCE_JSON_LOGGING and sys.stderr.isatty():
+        # Pretty printing when we run in a terminal session.
+        # Automatically prints pretty tracebacks when "rich" is installed
+        processors = shared_processors + [
+            HumanConsoleRenderer(),
+        ]
+    else:
+        # Print JSON when we run, e.g., in a Docker container.
+        # Also print structured tracebacks.
+        processors = shared_processors + [
+            structlog.processors.dict_tracebacks,
+            structlog.processors.JSONRenderer(),
+        ]
+
+    structlog.configure(
+        processors=processors,  # type: ignore
+        context_class=dict,
+        # `logger_factory` is used to create wrapped loggers that are used for
+        # OUTPUT. This one returns a `logging.Logger`. The final value (a JSON
+        # string) from the final processor (`JSONRenderer`) will be passed to
+        # the method of the same name as that you've called on the bound logger.
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        # `wrapper_class` is the bound logger that you get back from
+        # get_logger(). This one imitates the API of `logging.Logger`.
+        wrapper_class=structlog.make_filtering_bound_logger(log_level),
+        # Effectively freeze configuration after creating the first bound
+        # logger.
+        cache_logger_on_first_use=True,
+    )
+
+
+def log_llm(logger: Any, log_module: str, log_event: str, **kwargs: Any) -> None:
+    """Logs LLM-specific events depending on a flag passed through an environment
+    variable. If the module's flag is set to INFO (e.g.
+    LOG_PROMPT_LLM_COMMAND_GENERATOR=INFO), its prompt is logged at INFO level,
+    overriding the general log level setting.
+
+    Args:
+        logger: instance of the structlogger of the component
+        log_module: name of the module/component logging the event
+        log_event: string describing the log event
+        **kwargs: dictionary of additional logging context
+    """
+    log_level_llm_name = os.environ.get(ENV_LOG_LEVEL_LLM, DEFAULT_LOG_LEVEL_LLM)
+    log_level_llm = logging.getLevelName(log_level_llm_name.upper())
+
+    module_env_variable = ENV_LOG_LEVEL_LLM_MODULE_NAMES.get(
+        log_module, "LOG_LEVEL_LLM_" + log_module.upper()
+    )
+    log_level_llm_module_name = os.environ.get(
+        module_env_variable, DEFAULT_LOG_LEVEL_LLM
+    )
+    log_level_llm_module = logging.getLevelName(log_level_llm_module_name.upper())
+
+    # log at the highest specified level, e.g. max(DEBUG=10, INFO=20)
+    log_level = max(log_level_llm, log_level_llm_module)
+
+    logger.log(log_level, log_event, **kwargs)

rasa/utils/mapper.py

@@ -0,0 +1,210 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Text, Union
+
+import rasa.shared.data
+import rasa.shared.utils.io
+from rasa.shared.core.domain import (
+    KEY_ACTIONS,
+    KEY_ENTITIES,
+    KEY_FORMS,
+    KEY_INTENTS,
+    KEY_RESPONSES,
+    KEY_SLOTS,
+    Domain,
+)
+from rasa.shared.core.flows.yaml_flows_io import KEY_FLOWS, is_flows_file
+from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
+    KEY_RULE_NAME,
+    KEY_RULES,
+    KEY_STORIES,
+    KEY_STORY_NAME,
+    YAMLStoryReader,
+)
+from rasa.shared.nlu.training_data.formats.rasa_yaml import (
+    KEY_INTENT,
+    KEY_NLU,
+)
+from rasa.shared.utils.yaml import read_yaml_file
+
+
+class RasaPrimitiveStorageMapper:
+    """Maps the Rasa primitives to the file its located in."""
+
+    def __init__(
+        self,
+        domain_path: Optional[Union[Text, Path]] = None,
+        training_data_paths: Optional[Union[List[Text], List[Path], Text, Path]] = None,
+    ):
+        self._primitives: Dict[str, Dict] = {
+            "entities": {},
+            "slots": {},
+            "forms": {},
+            "intents": {},
+            "stories": {},
+            "rules": {},
+            "actions": {},
+            "responses": {},
+            "flows": {},
+        }
+
+        if domain_path:
+            self._load_domain(domain_path)
+
+        if training_data_paths:
+            self._load_training_data(training_data_paths)
+
+    def _load_domain(self, domain_path: Union[Text, Path]) -> None:
+        self._resolve_domain_files(domain_path)
+        self._parse_domain_files()
+
+    def _load_training_data(
+        self, training_data_paths: Union[List[Text], List[Path], Text, Path]
+    ) -> None:
+        self._resolve_training_data_files(training_data_paths)
+
+        self._nlu_files = rasa.shared.data.get_data_files(
+            self._training_data_paths, rasa.shared.data.is_nlu_file
+        )
+        self._parse_nlu_data()
+
+        self._story_files = rasa.shared.data.get_data_files(
+            self._training_data_paths, YAMLStoryReader.is_stories_file
+        )
+        self._parse_story_data()
+
+        self._flow_files = rasa.shared.data.get_data_files(
+            self._training_data_paths, is_flows_file
+        )
+        self._parse_flow_data()
+
+    def _resolve_training_data_files(
+        self, training_data_paths: Union[List[Text], List[Path], Text, Path]
+    ) -> None:
+        if isinstance(training_data_paths, list):
+            training_data_paths = [Path(p) for p in training_data_paths]
+        elif isinstance(training_data_paths, str):
+            training_data_paths = [Path(training_data_paths)]
+        elif isinstance(training_data_paths, Path):
+            training_data_paths = [training_data_paths]
+
+        self._training_data_paths = training_data_paths
+
+    def _resolve_domain_files(self, domain_path: Union[Text, Path]) -> None:
+        domain_path = Path(domain_path) if isinstance(domain_path, str) else domain_path
+
+        if domain_path.is_dir():
+            self._domain_files = [
+                file for file in domain_path.iterdir() if Domain.is_domain_file(file)
+            ]
+        else:
+            self._domain_files = [domain_path]
+
+    def _parse_domain_files(self) -> None:
+        for domain_file in self._domain_files:
+            content = read_yaml_file(domain_file)
+            for entity in content.get(KEY_ENTITIES, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["entities"], "domain", domain_file, entity
+                )
+            for intent in content.get(KEY_INTENTS, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["intents"], "domain", domain_file, intent
+                )
+            for slot in content.get(KEY_SLOTS, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["slots"], "domain", domain_file, slot
+                )
+            for form in content.get(KEY_FORMS, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["forms"], "domain", domain_file, form
+                )
+            for action in content.get(KEY_ACTIONS, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["actions"], "domain", domain_file, action
+                )
+            for response in content.get(KEY_RESPONSES, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["responses"], "domain", domain_file, response
+                )
+
+    def _parse_nlu_data(self) -> None:
+        """Parses the nlu data and extracts the intents."""
+        for nlu_file in self._nlu_files:
+            content = read_yaml_file(nlu_file)
+            for intent in content.get(KEY_NLU, []):  # type: ignore[union-attr]
+                if KEY_INTENT in intent:
+                    self._assign_value(
+                        self._primitives["intents"],
+                        "training",
+                        nlu_file,
+                        intent.get(KEY_INTENT),
+                    )
+
+    def _parse_story_data(self) -> None:
+        """Parses the story data and extracts the stories and rules."""
+        for story_file in self._story_files:
+            content = read_yaml_file(story_file)
+            for story in content.get(KEY_STORIES, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["stories"],
+                    "training",
+                    story_file,
+                    story[KEY_STORY_NAME],
+                )
+            for rule in content.get(KEY_RULES, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["rules"],
+                    "training",
+                    story_file,
+                    rule[KEY_RULE_NAME],
+                )
+
+    def _parse_flow_data(self) -> None:
+        """Parses the flow data and extracts the flow ids."""
+        for flow_file in self._flow_files:
+            content = read_yaml_file(flow_file)
+            for flow in content.get(KEY_FLOWS, []):  # type: ignore[union-attr]
+                self._assign_value(
+                    self._primitives["flows"],
+                    "training",
+                    flow_file,
+                    flow,
+                )
+
+    @staticmethod
+    def _assign_value(
+        primitive: Dict, file_type: str, value: Union[str, Path], key: str
+    ) -> None:
+        if not isinstance(value, Path):
+            value = Path(value)
+
+        if isinstance(key, dict):
+            key = next(iter(key.keys()))
+
+        if key in primitive:
+            if file_type in primitive[key]:
+                primitive[key][file_type].append(value)
+            else:
+                primitive[key][file_type] = [value]
+        else:
+            primitive[key] = {file_type: [value]}
+
+    def get_file(self, primitive: Text, primitive_type: Text) -> Dict[str, List[Path]]:
+        """Returns the file where the primitive is located.
+
+        If the primitive is not found, empty dict is returned.
+
+        Args:
+            primitive: The name or ID of the primitive to search for.
+            primitive_type: The type of the primitive to search for.
+                either entities, slots, forms, intents, stories or rules.
+
+        Returns:
+            A dictionary containing the file type and the list of file paths.
+            file_type can be either domain or training.
+            get_file()[file_type] -> List[Path]
+        """
+        try:
+            return self._primitives[primitive_type][primitive]
+        except KeyError:
+            return {}