rasa-pro 3.8.18__py3-none-any.whl → 3.9.15__py3-none-any.whl

rasa/utils/licensing.py

@@ -1,14 +1,27 @@
+from asyncio import AbstractEventLoop
 import hashlib
-import logging
 import os
+import random
 import re
 import time
+import typing
 import uuid
 from datetime import datetime, timezone
-from typing import Any, Callable, Dict, Optional, Set, Text
+from typing import Any, Callable, Dict, Optional, Set, Text, TypeVar
 
 import jwt
 from dotenv import dotenv_values
+from sanic import Sanic
+import structlog
+from rasa import telemetry
+
+from rasa.core import jobs
+from rasa.shared.utils.cli import print_error_and_exit
+
+
+if typing.TYPE_CHECKING:
+    from rasa.core.tracker_store import TrackerStore
+
 
 LICENSE_ENV_VAR = "RASA_PRO_LICENSE"
 ALGORITHM = "RS256"
@@ -32,8 +45,11 @@ JTI_BLOCKLIST: Set[Text] = set([])
 SCOPE_DELIMITER = ":"
 PRODUCT_AREA = "rasa:pro:plus"
 VOICE_SCOPE = "rasa:voice"
-
-logger = logging.getLogger(__name__)
+CHAMPION_SERVER_LIMITED_SCOPE = "rasa:pro:champion-server-limited"
+CHAMPION_SERVER_INTERNAL_SCOPE = "rasa:pro:champion-server-internal"
+# defines multiple of the soft limit that triggers the hard limit
+HARD_LIMIT_FACTOR = 10
+structlogger = structlog.get_logger()
 
 
 class LicenseValidationException(Exception):
@@ -64,6 +80,10 @@ class LicenseNotYetValidException(LicenseValidationException):
     """Exception raised when a license is not valid yet (nbf)."""
 
 
+class LicenseNotFoundException(LicenseValidationException):
+    """Exception raised when a license is not available."""
+
+
 class License:
     """Represents a Rasa Pro license.
 
@@ -80,6 +100,37 @@ class License:
       requires access to the private key to then encode) or for testing
       purposes.
 
+    The scopes of the license define what it unlocks. The scopes are
+    hierarchical, meaning that a license with a scope `rasa:pro` also
+    unlocks the scopes `rasa:pro:plus`.
+
+    Scopes can be used to enable or disable features in Rasa, the following
+    scopes are used:
+
+    - `rasa:pro` - Rasa Pro features
+    - `rasa:pro:plus` - Rasa Pro Plus features
+    - `rasa:voice` - Voice features
+
+    In addition to scopes focused on feature flagging, there are also scopes
+    that are used to limited by the license agreement they are issued under:
+
+    - `rasa:pro:champion` - Champion license, can only be used for local
+      development
+
+    - `rasa:pro:champion-server-internal` - Champion license, can be used
+      to deploy an assistant on a server for an internal use case. The license
+      limits the number of conversations per month to 100.
+
+    - `rasa:pro:champion-server-limited` - Champion license, can be used
+        to deploy an assistant on a server for a limited external use case.
+        The license allows for a maximum of 1000 conversations per month.
+
+    The champion scopes on their own do not unlock any features, they are
+    used to limit the use of the license to the agreed upon number of
+    conversations. The champion scopes can be combined with the feature
+    scopes to enable the features for the champion license, e.g.
+    `rasa:pro:champion rasa:pro` would enable the champion license for
+    local development and the Rasa Pro features.
     """
 
     __slots__ = ["jti", "iat", "nbf", "scope", "exp", "email", "company"]
@@ -215,39 +266,44 @@ class 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. "
-        )
+        raise LicenseNotFoundException()
     return license
 
 
+def is_license_expiring_soon(license: License) -> bool:
+    """Check if the license is about to expire in less than 30 days."""
+    return license.exp - time.time() < 30 * 24 * 60 * 60
+
+
 def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
-    license = retrieve_license_from_env()
     try:
-        License.decode(license, product_area=product_area)
+        license_text = retrieve_license_from_env()
+        license = License.decode(license_text, product_area=product_area)
+
+        if is_license_expiring_soon(license):
+            structlogger.warning(
+                "license.expiration.warning",
+                event_info=(
+                    "Your license is about to expire. "
+                    "Please contact Rasa for a renewal."
+                ),
+                expiration_date=datetime.utcfromtimestamp(license.exp).isoformat(),
+            )
+    except LicenseNotFoundException:
+        structlogger.error("license.not_found.error")
+        raise SystemExit(
+            f"A Rasa Pro license is required. "
+            f"Please set the environmental variable "
+            f"`{LICENSE_ENV_VAR}` to a valid license string. "
+        )
     except LicenseValidationException as e:
-        logger.error(e)
+        structlogger.error("license.validation.error", error=e)
         raise SystemExit(
             f"Failed to validate Rasa Pro license "
             f"which was read from environmental variable `{LICENSE_ENV_VAR}`. "
@@ -295,21 +351,25 @@ def derive_scope_hierarchy(scope: Text) -> Set[Text]:
     return set(required_scopes)
 
 
-def property_of_active_license(prop: Callable[[License], str]) -> Optional[str]:
+T = TypeVar("T")
+
+
+def property_of_active_license(prop: Callable[[License], T]) -> Optional[T]:
     """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:
+        retrieved_license = retrieve_license_from_env()
+        if not retrieved_license:
+            return None
         decoded = License.decode(retrieved_license)
         return prop(decoded)
+    except LicenseNotFoundException:
+        return None
     except LicenseValidationException as e:
-        logger.warning("The provided license is invalid.", exc_info=e)
+        structlogger.warn("licensing.active_license.invalid", error=e)
         return None
 
 
@@ -317,3 +377,158 @@ 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()
+
+
+def is_champion_server_license() -> bool:
+    """Return whether the current license is a developer license."""
+
+    def has_developer_license_scope(license: License) -> bool:
+        if CHAMPION_SERVER_LIMITED_SCOPE in license.scope:
+            return True
+        if CHAMPION_SERVER_INTERNAL_SCOPE in license.scope:
+            return True
+        return False
+
+    # or False is needed to handle the case where the license is not set
+    # this is to please the type checker
+    return property_of_active_license(has_developer_license_scope) or False
+
+
+def conversation_limit_for_license() -> Optional[int]:
+    def conversations_limit(license: License) -> Optional[int]:
+        """Return maximum number of conversations per month for this license."""
+        scope = license.scope
+
+        if CHAMPION_SERVER_LIMITED_SCOPE in scope:
+            return 1000
+        if CHAMPION_SERVER_INTERNAL_SCOPE in scope:
+            return 100
+        return None
+
+    return property_of_active_license(conversations_limit)
+
+
+async def validate_limited_server_license(app: Sanic, loop: AbstractEventLoop) -> None:
+    """Validate a limited server license and schedule conversation counting job."""
+    max_number_conversations = conversation_limit_for_license()
+
+    if app.ctx.agent:
+        if max_number_conversations is None:
+            structlogger.debug("licensing.server_limit.unlimited")
+        else:
+            store = app.ctx.agent.tracker_store
+            await run_conversation_counting(store, max_number_conversations)
+            await _schedule_conversation_counting(app, store, max_number_conversations)
+    else:
+        structlogger.warn("licensing.validate_limited_server_license.no_agent")
+
+
+async def handle_soft_limit_reached(
+    conversation_count: int, max_number_conversations: int, month: datetime
+) -> None:
+    """Log a warning when the number of conversations exceeds the soft limit."""
+    structlogger.error(
+        "licensing.conversation_count.exceeded",
+        event_info=(
+            "The number of conversations has exceeded the limit granted "
+            "by your license. Please contact us to upgrade your license."
+        ),
+        conversation_count=conversation_count,
+        max_number_conversations=max_number_conversations,
+    )
+    telemetry.track_conversation_count_soft_limit(conversation_count, month)
+
+
+async def handle_hard_limit_reached(
+    conversation_count: int, max_number_conversations: int, month: datetime
+) -> None:
+    """Log an error when the number of conversations exceeds the hard limit."""
+    structlogger.error(
+        "licensing.conversation_count.exceeded",
+        event_info=(
+            "The number of conversations has exceeded the limit granted "
+            "by your license. Please contact us to upgrade your license."
+        ),
+        conversation_count=conversation_count,
+        max_number_conversations=max_number_conversations,
+    )
+    telemetry.track_conversation_count_hard_limit(conversation_count, month)
+    print_error_and_exit(
+        "The number of conversations has exceeded the limit granted by your "
+        "license. Please contact us to upgrade your license."
+    )
+
+
+def current_utc_month() -> datetime:
+    """Return the current month in UTC timezone."""
+    return datetime.now(timezone.utc).replace(
+        day=1, hour=0, minute=0, second=0, microsecond=0
+    )
+
+
+async def run_conversation_counting(
+    tracker_store: Optional["TrackerStore"], max_number_conversations: int
+) -> None:
+    """Count the number of conversations started in the current month and log it."""
+    start_of_month_utc = current_utc_month()
+    start_of_month_timestamp = start_of_month_utc.timestamp()
+
+    conversation_count = await _count_conversations_after(
+        tracker_store, start_of_month_timestamp
+    )
+
+    if conversation_count >= max_number_conversations * HARD_LIMIT_FACTOR:
+        # user is above the hard limit
+        await handle_hard_limit_reached(
+            conversation_count, max_number_conversations, start_of_month_utc
+        )
+    elif conversation_count > max_number_conversations:
+        await handle_soft_limit_reached(
+            conversation_count, max_number_conversations, start_of_month_utc
+        )
+
+    structlogger.debug(
+        "licensing.conversation_count",
+        conversation_count=conversation_count,
+        max_number_conversations=max_number_conversations,
+    )
+    telemetry.track_conversation_count(conversation_count, start_of_month_utc)
+
+
+async def _schedule_conversation_counting(
+    app: Sanic, tracker_store: Optional["TrackerStore"], max_number_conversations: int
+) -> None:
+    """Schedule a job counting the number of conversations in the current month."""
+
+    async def conversation_counting_job(
+        app: Sanic,
+        tracker_store: Optional["TrackerStore"],
+        max_number_conversations: int,
+    ) -> None:
+        try:
+            await run_conversation_counting(tracker_store, max_number_conversations)
+        except SystemExit:
+            # we've reached the conversation limit
+            app.stop()
+
+    (await jobs.scheduler()).add_job(
+        conversation_counting_job,
+        "interval",
+        # every 24 hours with a random offset of max 1 hour
+        # clusters tend to get started at the same time, this avoids them
+        # doing the "conversation counting work" at exactly the same time
+        seconds=24 * 60 * 60 + random.randint(0, 60 * 60),
+        args=[app, tracker_store, max_number_conversations],
+        id="count-conversations",
+        replace_existing=True,
+    )
+
+
+async def _count_conversations_after(
+    tracker_store: Optional["TrackerStore"], after_timestamp: float
+) -> int:
+    """Count the number of conversations started in the current month."""
+    if tracker_store is None:
+        return 0
+
+    return await tracker_store.count_conversations(after_timestamp=after_timestamp)

rasa/utils/ml_utils.py

@@ -64,7 +64,7 @@ def extract_participant_messages_from_transcript(
 
 
 def extract_ai_response_examples(
-    responses: Dict[Text, List[Dict[Text, Any]]]
+    responses: Dict[Text, List[Dict[Text, Any]]],
 ) -> List[str]:
     """Extracts the responses from the domain.
 

rasa/utils/tensorflow/data_generator.py

@@ -217,7 +217,7 @@ class RasaDataGenerator(Sequence):
         # we need to make sure that the matrices are coo_matrices otherwise the
         # transformation does not work (e.g. you cannot access x.row, x.col)
         if not isinstance(array_of_sparse[0], scipy.sparse.coo_matrix):
-            array_of_sparse = [x.tocoo() for x in array_of_sparse]  # type: ignore[assignment]  # noqa: E501
+            array_of_sparse = [x.tocoo() for x in array_of_sparse]  # type: ignore[assignment]
 
         max_seq_len = max([x.shape[0] for x in array_of_sparse])
 

rasa/utils/tensorflow/environment.py

@@ -98,7 +98,7 @@ def _parse_gpu_config(gpu_memory_config: Text) -> Dict[int, int]:
         # Helper explanation of where the error comes from
         raise ValueError(
             f"Error parsing GPU configuration. Please cross-check the format of "
-            f"'{ENV_GPU_CONFIG}' at https://rasa.com/docs/rasa/tuning-your-model"
+            f"'{ENV_GPU_CONFIG}' at https://rasa.com/docs/rasa-pro/nlu-based-assistants/tuning-your-model"
             f"#restricting-absolute-gpu-memory-available ."
         )
 

rasa/utils/tensorflow/model_data.py

@@ -20,8 +20,6 @@ import numpy as np
 import scipy.sparse
 from sklearn.model_selection import train_test_split
 
-from rasa.utils.tensorflow.feature_array import FeatureArray
-
 logger = logging.getLogger(__name__)
 
 
@@ -39,6 +37,199 @@ def ragged_array_to_ndarray(ragged_array: Iterable[np.ndarray]) -> np.ndarray:
         return np.array(ragged_array, dtype=object)
 
 
+class FeatureArray(np.ndarray):
+    """Stores any kind of features ready to be used by a RasaModel.
+
+    Next to the input numpy array of features, it also received the number of
+    dimensions of the features.
+    As our features can have 1 to 4 dimensions we might have different number of numpy
+    arrays stacked. The number of dimensions helps us to figure out how to handle this
+    particular feature array. Also, it is automatically determined whether the feature
+    array is sparse or not and the number of units is determined as well.
+
+    Subclassing np.array: https://numpy.org/doc/stable/user/basics.subclassing.html
+    """
+
+    def __new__(
+        cls, input_array: np.ndarray, number_of_dimensions: int
+    ) -> "FeatureArray":
+        """Create and return a new object.  See help(type) for accurate signature."""
+        FeatureArray._validate_number_of_dimensions(number_of_dimensions, input_array)
+
+        feature_array = np.asarray(input_array).view(cls)
+
+        if number_of_dimensions <= 2:
+            feature_array.units = input_array.shape[-1]
+            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
+        elif number_of_dimensions == 3:
+            feature_array.units = input_array[0].shape[-1]
+            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
+        elif number_of_dimensions == 4:
+            feature_array.units = input_array[0][0].shape[-1]
+            feature_array.is_sparse = isinstance(
+                input_array[0][0], scipy.sparse.spmatrix
+            )
+        else:
+            raise ValueError(
+                f"Number of dimensions '{number_of_dimensions}' currently not "
+                f"supported."
+            )
+
+        feature_array.number_of_dimensions = number_of_dimensions
+
+        return feature_array
+
+    def __init__(
+        self, input_array: Any, number_of_dimensions: int, **kwargs: Any
+    ) -> None:
+        """Initialize. FeatureArray.
+
+        Needed in order to avoid 'Invalid keyword argument number_of_dimensions
+        to function FeatureArray.__init__ '
+        Args:
+            input_array: the array that contains features
+            number_of_dimensions: number of dimensions in input_array
+        """
+        super().__init__(**kwargs)
+        self.number_of_dimensions = number_of_dimensions
+
+    def __array_finalize__(self, obj: Optional[np.ndarray]) -> None:
+        """This method is called when the system allocates a new array from obj.
+
+        Args:
+            obj: A subclass (subtype) of ndarray.
+        """
+        if obj is None:
+            return
+
+        self.units = getattr(obj, "units", None)
+        self.number_of_dimensions = getattr(obj, "number_of_dimensions", None)  # type: ignore[assignment]
+        self.is_sparse = getattr(obj, "is_sparse", None)
+
+        default_attributes = {
+            "units": self.units,
+            "number_of_dimensions": self.number_of_dimensions,
+            "is_spare": self.is_sparse,
+        }
+        self.__dict__.update(default_attributes)
+
+    # pytype: disable=attribute-error
+    def __array_ufunc__(
+        self, ufunc: Any, method: Text, *inputs: Any, **kwargs: Any
+    ) -> Any:
+        """Overwrite this method as we are subclassing numpy array.
+
+        Args:
+            ufunc: The ufunc object that was called.
+            method: A string indicating which Ufunc method was called
+                    (one of "__call__", "reduce", "reduceat", "accumulate", "outer",
+                    "inner").
+            *inputs: A tuple of the input arguments to the ufunc.
+            **kwargs: Any additional arguments
+
+        Returns:
+            The result of the operation.
+        """
+        f = {
+            "reduce": ufunc.reduce,
+            "accumulate": ufunc.accumulate,
+            "reduceat": ufunc.reduceat,
+            "outer": ufunc.outer,
+            "at": ufunc.at,
+            "__call__": ufunc,
+        }
+        # convert the inputs to np.ndarray to prevent recursion, call the function,
+        # then cast it back as FeatureArray
+        output = FeatureArray(
+            f[method](*(i.view(np.ndarray) for i in inputs), **kwargs),
+            number_of_dimensions=kwargs["number_of_dimensions"],
+        )
+        output.__dict__ = self.__dict__  # carry forward attributes
+        return output
+
+    def __reduce__(self) -> Tuple[Any, Any, Any]:
+        """Needed in order to pickle this object.
+
+        Returns:
+            A tuple.
+        """
+        pickled_state = super(FeatureArray, self).__reduce__()
+        if isinstance(pickled_state, str):
+            raise TypeError("np array __reduce__ returned string instead of tuple.")
+        new_state = pickled_state[2] + (
+            self.number_of_dimensions,
+            self.is_sparse,
+            self.units,
+        )
+        return pickled_state[0], pickled_state[1], new_state
+
+    def __setstate__(self, state: Any, **kwargs: Any) -> None:
+        """Sets the state.
+
+        Args:
+            state: The state argument must be a sequence that contains the following
+                   elements version, shape, dtype, isFortan, rawdata.
+            **kwargs: Any additional parameter
+        """
+        # Needed in order to load the object
+        self.number_of_dimensions = state[-3]
+        self.is_sparse = state[-2]
+        self.units = state[-1]
+        super(FeatureArray, self).__setstate__(state[0:-3], **kwargs)
+
+    # pytype: enable=attribute-error
+
+    @staticmethod
+    def _validate_number_of_dimensions(
+        number_of_dimensions: int, input_array: np.ndarray
+    ) -> None:
+        """Validates if the the input array has given number of dimensions.
+
+        Args:
+            number_of_dimensions: number of dimensions
+            input_array: input array
+
+        Raises: ValueError in case the dimensions do not match
+        """
+        _sub_array = input_array
+        dim = 0
+        # Go number_of_dimensions into the given input_array
+        for i in range(1, number_of_dimensions + 1):
+            _sub_array = _sub_array[0]
+            if isinstance(_sub_array, scipy.sparse.spmatrix):
+                dim = i
+                break
+            if isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
+                # sequence dimension is 0, we are dealing with "fake" features
+                dim = i
+                break
+
+        # If the resulting sub_array is sparse, the remaining number of dimensions
+        # should be at least 2
+        if isinstance(_sub_array, scipy.sparse.spmatrix):
+            if dim > 2:
+                raise ValueError(
+                    f"Given number of dimensions '{number_of_dimensions}' does not "
+                    f"match dimensions of given input array: {input_array}."
+                )
+        elif isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
+            # sequence dimension is 0, we are dealing with "fake" features,
+            # but they should be of dim 2
+            if dim > 2:
+                raise ValueError(
+                    f"Given number of dimensions '{number_of_dimensions}' does not "
+                    f"match dimensions of given input array: {input_array}."
+                )
+        # If the resulting sub_array is dense, the sub_array should be a single number
+        elif not np.issubdtype(type(_sub_array), np.integer) and not isinstance(
+            _sub_array, (np.float32, np.float64)
+        ):
+            raise ValueError(
+                f"Given number of dimensions '{number_of_dimensions}' does not match "
+                f"dimensions of given input array: {input_array}."
+            )
+
+
 class FeatureSignature(NamedTuple):
     """Signature of feature arrays.
 
@@ -94,12 +285,10 @@ class RasaModelData:
         self.sparse_feature_sizes: Dict[Text, Dict[Text, List[int]]] = {}
 
     @overload
-    def get(self, key: Text, sub_key: Text) -> List[FeatureArray]:
-        ...
+    def get(self, key: Text, sub_key: Text) -> List[FeatureArray]: ...
 
     @overload
-    def get(self, key: Text, sub_key: None = ...) -> Dict[Text, List[FeatureArray]]:
-        ...
+    def get(self, key: Text, sub_key: None = ...) -> Dict[Text, List[FeatureArray]]: ...
 
     def get(
         self, key: Text, sub_key: Optional[Text] = None
@@ -548,9 +737,9 @@ class RasaModelData:
         # if a label was skipped in current batch
         skipped = [False] * num_label_ids
 
-        new_data: DefaultDict[
-            Text, DefaultDict[Text, List[List[FeatureArray]]]
-        ] = defaultdict(lambda: defaultdict(list))
+        new_data: DefaultDict[Text, DefaultDict[Text, List[List[FeatureArray]]]] = (
+            defaultdict(lambda: defaultdict(list))
+        )
 
         while min(num_data_cycles) == 0:
             if shuffle:
@@ -701,9 +890,9 @@ class RasaModelData:
         Returns:
             The test and train RasaModelData
         """
-        data_train: DefaultDict[
-            Text, DefaultDict[Text, List[FeatureArray]]
-        ] = defaultdict(lambda: defaultdict(list))
+        data_train: DefaultDict[Text, DefaultDict[Text, List[FeatureArray]]] = (
+            defaultdict(lambda: defaultdict(list))
+        )
         data_val: DefaultDict[Text, DefaultDict[Text, List[Any]]] = defaultdict(
             lambda: defaultdict(list)
         )