rasa-pro 3.14.0a17__tar.gz → 3.14.0a19__tar.gz

{rasa_pro-3.14.0a17 → rasa_pro-3.14.0a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.14.0a17
+Version: 3.14.0a19
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH
@@ -28,6 +28,7 @@ Requires-Dist: absl-py (>=2.0,<2.1)
 Requires-Dist: aio-pika (>=8.2.3,<9.4.4)
 Requires-Dist: aiogram (>=3.22.0,<3.23.0)
 Requires-Dist: aiohttp (>=3.10,<3.11)
+Requires-Dist: aioshutil (>=1.5,<2.0)
 Requires-Dist: apscheduler (>=3.10,<3.11)
 Requires-Dist: attrs (>=23.1,<23.2)
 Requires-Dist: aws-msk-iam-sasl-signer-python (>=1.0.2,<1.1.0)

{rasa_pro-3.14.0a17 → rasa_pro-3.14.0a19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.14.0a17"
+version = "3.14.0a19"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -240,6 +240,7 @@ demoji = "^1.1.0"
 azure-identity = "~1.24.0"
 langcodes = "^3.5.0"
 sanic-openapi = "^21.12.0"
+aioshutil = "^1.5"
 aws-msk-iam-sasl-signer-python = "~1.0.2"
 
 [[tool.poetry.dependencies.gliner]]
@@ -386,6 +387,7 @@ convention = "google"
 "tests/shared/core/test_domain.py" = [ "E501",]
 
 
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.14.0a17 → rasa_pro-3.14.0a19}/rasa/builder/main.py

@@ -22,11 +22,9 @@ from rasa.builder.logging_utils import (
     log_request_start,
 )
 from rasa.builder.service import bp, setup_project_generator
-from rasa.builder.template_cache import (
-    background_download_template_caches,
-)
 from rasa.builder.training_service import try_load_existing_agent, update_agent
 from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.model_manager.warm_rasa_process import warmup
 from rasa.server import configure_cors
 from rasa.utils.common import configure_logging_and_warnings
 from rasa.utils.log_utils import configure_structlog
@@ -150,16 +148,6 @@ def create_app(project_folder: str) -> Sanic:
         except Exception as e:
             structlogger.warning("Failed to load agent on server startup", error=str(e))
 
-    if config.HELLO_RASA_PROJECT_ID and app.ctx.project_generator.is_empty():
-        app.register_listener(background_download_template_caches, "after_server_start")
-    else:
-        structlogger.debug(
-            "builder.main.background_cache_download.disabled",
-            event_info=(
-                "No hello rasa project id set; skipping background cache download"
-            ),
-        )
-
     return app
 
 
@@ -200,9 +188,12 @@ def main(project_folder: Optional[str] = None) -> None:
         rasa.telemetry.initialize_telemetry()
         rasa.telemetry.initialize_error_reporting(private_mode=False)
 
-        # TODO: don't do this when running locally
         _apply_llm_overrides_from_builder_env()
 
+        if config.HELLO_RASA_PROJECT_ID:
+            # ensures long import times for modules are ahead of time
+            warmup()
+
         # working directory needs to be the project folder, e.g.
         # for relative paths (./docs) in a projects config to work
         if not project_folder:

{rasa_pro-3.14.0a17 → rasa_pro-3.14.0a19}/rasa/builder/project_generator.py

@@ -62,7 +62,7 @@ class ProjectGenerator:
         create_initial_project(self.project_folder.as_posix(), template)
         # If a local cache for this template exists, copy it into the project.
         # We no longer download here to avoid blocking project creation.
-        copy_cache_for_template_if_available(template, self.project_folder)
+        await copy_cache_for_template_if_available(template, self.project_folder)
         # needs to happen after caching, as we download/copy .rasa and that would
         # overwrite the project info file in .rasa
         ensure_first_used(self.project_folder)

rasa_pro-3.14.0a19/rasa/builder/template_cache.py

@@ -0,0 +1,69 @@
+import os
+from pathlib import Path
+
+import aiofiles
+import aiofiles.os
+import aioshutil
+import structlog
+
+from rasa.cli.scaffold import ProjectTemplateName
+
+structlogger = structlog.get_logger()
+
+
+# Root directory for storing downloaded template caches on disk.
+_CACHE_ROOT_DIR = Path(os.getenv("RASA_TEMPLATE_CACHE_DIR", "/templates"))
+
+
+def _template_cache_dir(template: ProjectTemplateName) -> Path:
+    """Return the local cache directory for a given template and version."""
+    return _CACHE_ROOT_DIR / template.value
+
+
+async def _copytree(src: Path, dst: Path) -> None:
+    """Copy directory tree from src to dst, merging into dst.
+
+    Existing files are overwritten. Hidden files and directories are included, as
+    caches can contain `.rasa` metadata that should be applied before calling
+    `ensure_first_used`.
+    """
+    for root, dirs, files in os.walk(src):
+        rel_path = Path(root).relative_to(src)
+        target_dir = dst / rel_path
+        await aiofiles.os.makedirs(target_dir, exist_ok=True)
+        for filename in files:
+            src_file = Path(root) / filename
+            dst_file = target_dir / filename
+            await aioshutil.copy2(src_file, dst_file)
+
+
+async def copy_cache_for_template_if_available(
+    template: ProjectTemplateName, project_folder: Path
+) -> None:
+    """Copy a previously downloaded cache for `template` into `project_folder`.
+
+    If the cache does not exist, this function is a no-op.
+    """
+    try:
+        cache_dir = _template_cache_dir(template)
+        if cache_dir.exists() and any(cache_dir.iterdir()):
+            await _copytree(cache_dir, project_folder)
+            structlogger.info(
+                "project_generator.copy_cache_for_template.success",
+                template=template,
+                event_info=(
+                    "Copied cached template files from cache to project folder."
+                ),
+            )
+        else:
+            structlogger.debug(
+                "project_generator.copy_cache_for_template.missing",
+                template=template,
+                event_info=("No local cache found for template; skipping copy."),
+            )
+    except Exception as exc:
+        structlogger.warning(
+            "project_generator.copy_cache_for_template.error",
+            error=str(exc),
+            template=template,
+        )

{rasa_pro-3.14.0a17 → rasa_pro-3.14.0a19}/rasa/core/concurrent_lock_store.py

@@ -4,6 +4,7 @@ from collections import deque
 from typing import Deque, Optional, Text
 
 import structlog
+from pydantic import ValidationError
 
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
@@ -12,6 +13,12 @@ from rasa.core.lock_store import (
     LockError,
     LockStore,
 )
+from rasa.core.redis_connection_factory import (
+    DeploymentMode,
+    RedisConfig,
+    RedisConnectionFactory,
+)
+from rasa.shared.exceptions import RasaException
 from rasa.utils.endpoints import EndpointConfig
 
 DEFAULT_REDIS_DB = 1
@@ -74,9 +81,10 @@ class ConcurrentRedisLockStore(LockStore):
                 alphanumeric.
             socket_timeout - Timeout in seconds after which an exception will be raised
                 in case Redis doesn't respond within `socket_timeout` seconds.
+            deployment_mode - Redis deployment mode: standard, cluster, or sentinel.
+            endpoints - List of endpoints for cluster/sentinel mode in host:port format.
+            sentinel_service - Sentinel service name.
         """
-        import redis
-
         host = endpoint_config.kwargs.get("host", DEFAULT_HOSTNAME)
         port = endpoint_config.kwargs.get("port", DEFAULT_PORT)
         db = endpoint_config.kwargs.get("db", DEFAULT_REDIS_DB)
@@ -90,20 +98,33 @@ class ConcurrentRedisLockStore(LockStore):
         socket_timeout = endpoint_config.kwargs.get(
             "socket_timeout", DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
         )
-
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
+        deployment_mode = endpoint_config.kwargs.get(
+            "deployment_mode", DeploymentMode.STANDARD.value
         )
+        endpoints = endpoint_config.kwargs.get("endpoints", [])
+        sentinel_service = endpoint_config.kwargs.get("sentinel_service")
 
+        try:
+            redis_config = RedisConfig(
+                host=host,
+                port=port,
+                db=db,
+                username=username,
+                password=password,
+                use_ssl=use_ssl,
+                ssl_certfile=ssl_certfile,
+                ssl_keyfile=ssl_keyfile,
+                ssl_ca_certs=ssl_ca_certs,
+                socket_timeout=socket_timeout,
+                deployment_mode=deployment_mode,
+                endpoints=endpoints,
+                sentinel_service=sentinel_service,
+            )
+            self.red = RedisConnectionFactory.create_connection(redis_config)
+        except ValidationError as e:
+            raise RasaException(f"Invalid Redis configuration: {e}")
+
+        self.deployment_mode = deployment_mode
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
             structlogger.debug(
@@ -129,6 +150,32 @@ class ConcurrentRedisLockStore(LockStore):
                 ),
             )
 
+    def _get_keys_by_pattern(self, pattern: Text) -> list:
+        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
+        if self.deployment_mode == DeploymentMode.CLUSTER.value:
+            # In cluster mode, use SCAN to get keys more reliably
+            keys = []
+            cursor = 0
+
+            while True:
+                try:
+                    cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
+                    keys.extend(batch_keys)
+                    if cursor == 0:
+                        break
+                except Exception as e:
+                    structlogger.warning(
+                        "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
+                        event_info=f"SCAN interrupted in cluster mode: {e}. "
+                        f"Returning {len(keys)} keys found so far.",
+                    )
+                    break
+        else:
+            # Standard and sentinel modes use KEYS
+            keys = self.red.keys(pattern)
+
+        return keys
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:
@@ -157,11 +204,14 @@ class ConcurrentRedisLockStore(LockStore):
         tickets: Deque[Ticket] = deque()
 
         pattern = self.key_prefix + conversation_id + ":" + "[0-9]*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         for key in redis_keys:
             serialised_ticket = self.red.get(key)
             if serialised_ticket:
+                # Handle bytes to string conversion for JSON parsing
+                if isinstance(serialised_ticket, bytes):
+                    serialised_ticket = serialised_ticket.decode("utf-8")
                 ticket = Ticket.from_dict(json.loads(serialised_ticket))
                 tickets.appendleft(ticket)
 
@@ -172,7 +222,7 @@ class ConcurrentRedisLockStore(LockStore):
     def delete_lock(self, conversation_id: Text) -> None:
         """Deletes lock for conversation ID."""
         pattern = self.key_prefix + conversation_id + ":*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         if not redis_keys:
             structlogger.debug(

{rasa_pro-3.14.0a17 → rasa_pro-3.14.0a19}/rasa/model_manager/warm_rasa_process.py

@@ -1,6 +1,7 @@
 import os
 import shlex
 import subprocess
+import time
 import uuid
 from dataclasses import dataclass
 from typing import List
@@ -149,19 +150,29 @@ def warmup() -> None:
     We import them now, so that the training / deployment can later
     directly start.
     """
+    start_time = time.time()
     try:
         import langchain  # noqa: F401
         import litellm  # noqa: F401
         import matplotlib  # noqa: F401
         import numpy  # noqa: F401
         import pandas  # noqa: F401
-        import presidio_analyzer  # noqa: F401
         import spacy  # noqa: F401
         import tensorflow  # noqa: F401
 
         import rasa.validator  # noqa: F401
-    except ImportError:
+    except ImportError as e:
+        structlogger.warning(
+            "model_trainer.warmup_error",
+            error=str(e),
+        )
         pass
+    finally:
+        end_time = time.time()
+        structlogger.debug(
+            "model_trainer.warmup_time",
+            time_in_seconds=end_time - start_time,
+        )
 
 
 def warm_rasa_main() -> None:

{rasa_pro-3.14.0a17 → rasa_pro-3.14.0a19}/rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.14.0a17"
+__version__ = "3.14.0a19"

rasa_pro-3.14.0a17/rasa/builder/template_cache.py

@@ -1,244 +0,0 @@
-import asyncio
-import os
-import shutil
-import tarfile
-import tempfile
-from pathlib import Path
-from typing import Generator
-
-import aiofiles
-import aiohttp
-import structlog
-from sanic import Sanic
-
-import rasa.version
-from rasa.builder.logging_utils import capture_exception_with_context
-from rasa.cli.scaffold import ProjectTemplateName
-
-structlogger = structlog.get_logger()
-
-CACHE_BUCKET_URL = "https://trained-templates.s3.us-east-1.amazonaws.com"
-
-# Root directory for storing downloaded template caches on disk.
-_CACHE_ROOT_DIR = Path(
-    os.getenv(
-        "RASA_TEMPLATE_CACHE_DIR",
-        Path.home().joinpath(".rasa", "template-cache").as_posix(),
-    )
-)
-
-
-def _template_cache_dir(template: ProjectTemplateName) -> Path:
-    """Return the local cache directory for a given template and version."""
-    return _CACHE_ROOT_DIR / rasa.version.__version__ / template.value
-
-
-def _cache_root_dir() -> Path:
-    return Path(
-        os.getenv(
-            "RASA_TEMPLATE_CACHE_DIR",
-            Path.home().joinpath(".rasa", "template-cache").as_posix(),
-        )
-    )
-
-
-def _safe_tar_members(
-    tar: tarfile.TarFile, destination_directory: Path
-) -> Generator[tarfile.TarInfo, None, None]:
-    """Yield safe members for extraction to prevent path traversal and links.
-
-    Args:
-        tar: Open tar file handle
-        destination_directory: Directory to which files will be extracted
-
-    Yields:
-        Members that are safe to extract within destination_directory
-    """
-    base_path = destination_directory.resolve()
-
-    for member in tar.getmembers():
-        name = member.name
-        # Skip empty names and absolute paths
-        if not name or name.startswith("/") or name.startswith("\\"):
-            continue
-
-        # Disallow symlinks and hardlinks
-        if member.issym() or member.islnk():
-            continue
-
-        # Compute the final path and ensure it's within base_path
-        target_path = (base_path / name).resolve()
-        try:
-            target_path.relative_to(base_path)
-        except ValueError:
-            # Member would escape the destination directory
-            continue
-
-        yield member
-
-
-def _copytree(src: Path, dst: Path) -> None:
-    """Copy directory tree from src to dst, merging into dst.
-
-    Existing files are overwritten. Hidden files and directories are included, as
-    caches can contain `.rasa` metadata that should be applied before calling
-    `ensure_first_used`.
-    """
-    for root, dirs, files in os.walk(src):
-        rel_path = Path(root).relative_to(src)
-        target_dir = dst / rel_path
-        target_dir.mkdir(parents=True, exist_ok=True)
-        for filename in files:
-            src_file = Path(root) / filename
-            dst_file = target_dir / filename
-            shutil.copy2(src_file, dst_file)
-
-
-async def download_cache_for_template(
-    template: ProjectTemplateName, target_dir: str
-) -> None:
-    # get a temp path for the cache file download
-    temporary_cache_file = tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False)
-
-    try:
-        url = f"{CACHE_BUCKET_URL}/{rasa.version.__version__}-{template.value}.tar.gz"
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url) as response:
-                response.raise_for_status()
-                async with aiofiles.open(temporary_cache_file.name, "wb") as f:
-                    async for chunk in response.content.iter_chunked(1024 * 1024):
-                        await f.write(chunk)
-
-        # extract the cache to the project folder using safe member filtering
-        with tarfile.open(temporary_cache_file.name, "r:gz") as tar:
-            destination = Path(target_dir)
-            destination.mkdir(parents=True, exist_ok=True)
-            tar.extractall(
-                path=destination,
-                members=_safe_tar_members(tar, destination),
-            )
-
-        structlogger.info(
-            "project_generator.download_cache_for_template.success",
-            template=template,
-            event_info=(
-                "Downloaded cache for template, extracted to target directory."
-            ),
-            target_dir=target_dir,
-        )
-    except aiohttp.ClientResponseError as e:
-        if e.status == 403:
-            structlogger.debug(
-                "project_generator.download_cache_for_template.no_cache_found",
-                template=template,
-                event_info=("No cache found for template, continuing without it."),
-                target_dir=target_dir,
-            )
-        else:
-            capture_exception_with_context(
-                e,
-                "project_generator.download_cache_for_template.response_error",
-                extra={
-                    "template": template.value,
-                    "status": str(e.status),
-                    "target_dir": target_dir,
-                },
-            )
-    except Exception as exc:
-        capture_exception_with_context(
-            exc,
-            "project_generator.download_cache_for_template.unexpected_error",
-            extra={"template": template.value, "target_dir": target_dir},
-        )
-    finally:
-        # Clean up the temporary file
-        try:
-            Path(temporary_cache_file.name).unlink(missing_ok=True)
-        except Exception as exc:
-            structlogger.debug(
-                "project_generator.download_cache_for_template.cleanup_error",
-                error=str(exc),
-                template=template,
-                event_info=("Failed to cleanup cache for template, ignoring."),
-            )
-
-
-async def background_download_template_caches(
-    app: Sanic, loop: asyncio.AbstractEventLoop
-) -> None:
-    """Kick off background downloads of template caches if enabled."""
-    try:
-        structlogger.info(
-            "builder.main.background_cache_download.start",
-            event_info=(
-                "Starting background download of template caches for this " "version"
-            ),
-        )
-
-        # Ensure cache root exists
-        _cache_root_dir().mkdir(parents=True, exist_ok=True)
-
-        async def _download(template: ProjectTemplateName) -> None:
-            try:
-                target_dir = _template_cache_dir(template)
-                if target_dir.exists() and any(target_dir.iterdir()):
-                    structlogger.debug(
-                        "builder.main.background_cache_download.skipped",
-                        template=template,
-                        event_info=(
-                            "Skipping download of template cache because it "
-                            "already exists."
-                        ),
-                        target_dir=target_dir,
-                    )
-                    return
-
-                target_dir.mkdir(parents=True, exist_ok=True)
-                await download_cache_for_template(template, target_dir.as_posix())
-            except Exception as exc:
-                structlogger.debug(
-                    "builder.main.background_cache_download.error",
-                    template=template,
-                    error=str(exc),
-                )
-
-        # schedule downloads concurrently without blocking startup
-        for template in ProjectTemplateName:
-            loop.create_task(_download(template))
-    except Exception as exc:
-        structlogger.debug(
-            "builder.main.background_cache_download.unexpected_error",
-            error=str(exc),
-        )
-
-
-def copy_cache_for_template_if_available(
-    template: ProjectTemplateName, project_folder: Path
-) -> None:
-    """Copy a previously downloaded cache for `template` into `project_folder`.
-
-    If the cache does not exist, this function is a no-op.
-    """
-    try:
-        cache_dir = _template_cache_dir(template)
-        if cache_dir.exists() and any(cache_dir.iterdir()):
-            _copytree(cache_dir, project_folder)
-            structlogger.info(
-                "project_generator.copy_cache_for_template.success",
-                template=template,
-                event_info=(
-                    "Copied cached template files from cache to project folder."
-                ),
-            )
-        else:
-            structlogger.debug(
-                "project_generator.copy_cache_for_template.missing",
-                template=template,
-                event_info=("No local cache found for template; skipping copy."),
-            )
-    except Exception as exc:
-        structlogger.warning(
-            "project_generator.copy_cache_for_template.error",
-            error=str(exc),
-            template=template,
-        )