rasa-pro 3.8.17__py3-none-any.whl → 3.9.14__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

@@ -103,7 +103,7 @@ class FeatureArray(np.ndarray):
             return
 
         self.units = getattr(obj, "units", None)
-        self.number_of_dimensions = getattr(obj, "number_of_dimensions", None)  # type: ignore[assignment] # noqa:E501
+        self.number_of_dimensions = getattr(obj, "number_of_dimensions", None)  # type: ignore[assignment]
         self.is_sparse = getattr(obj, "is_sparse", None)
 
         default_attributes = {
@@ -285,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
@@ -739,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:
@@ -892,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)
         )