rasa-pro 3.10.7.dev2__py3-none-any.whl → 3.10.7.dev4__py3-none-any.whl

rasa/core/channels/socketio.py

@@ -37,7 +37,11 @@ class SocketBlueprint(Blueprint):
         :param options: Options to be used while registering the
             blueprint into the app.
         """
-        self.ctx.sio.attach(app, self.ctx.socketio_path)
+        if self.ctx.socketio_path:
+            path = self.ctx.socketio_path
+        else:
+            path = options.get("url_prefix", "/socket.io")
+        self.ctx.sio.attach(app, path)
         super().register(app, options)
 
 

rasa/model_manager/model_api.py

@@ -2,7 +2,7 @@ import asyncio
 import os
 from typing import Any, Dict, Optional
 import dotenv
-from sanic import Sanic, response
+from sanic import Blueprint, Sanic, response
 from sanic.response import json
 from sanic.exceptions import NotFound
 from sanic.request import Request
@@ -35,12 +35,6 @@ dotenv.load_dotenv()
 
 structlogger = structlog.get_logger()
 
-# configure the sanice application
-app = Sanic("RasaManager")
-# attach the socketio server to the sanic app
-sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
-sio.attach(app, "/socket.io")
-
 
 # A simple in-memory store for training sessions and running bots
 trainings: Dict[str, TrainingSession] = {}
@@ -59,26 +53,30 @@ def prepare_working_directories() -> None:
 def cleanup_training_processes() -> None:
     """Terminate all running training processes."""
     structlogger.debug("model_trainer.cleanup_processes.started")
-    for training in trainings.values():
+    running = list(trainings.values())
+    for training in running:
         terminate_training(training)
 
 
 def cleanup_bot_processes() -> None:
     """Terminate all running bot processes."""
     structlogger.debug("model_runner.cleanup_processes.started")
-    for bot in running_bots.values():
+    running = list(running_bots.values())
+    for bot in running:
         terminate_bot(bot)
 
 
 def update_status_of_all_trainings() -> None:
     """Update the status of all training processes."""
-    for training in trainings.values():
+    running = list(trainings.values())
+    for training in running:
         update_training_status(training)
 
 
 async def update_status_of_all_bots() -> None:
     """Update the status of all bot processes."""
-    for bot in running_bots.values():
+    running = list(running_bots.values())
+    for bot in running:
         await update_bot_status(bot)
 
 
@@ -138,295 +136,329 @@ async def continuously_update_process_status() -> None:
         await asyncio.sleep(1)
 
 
-@app.before_server_stop
-async def cleanup_processes(app: Sanic, loop: asyncio.AbstractEventLoop) -> None:
-    """Terminate all running processes before the server stops."""
-    structlogger.debug("model_api.cleanup_processes.started")
-    cleanup_training_processes()
-    cleanup_bot_processes()
+def internal_blueprint() -> Blueprint:
+    """Create a blueprint for the model manager API."""
+    bp = Blueprint("model_api_internal")
 
+    @bp.before_server_stop
+    async def cleanup_processes(app: Sanic, loop: asyncio.AbstractEventLoop) -> None:
+        """Terminate all running processes before the server stops."""
+        structlogger.debug("model_api.cleanup_processes.started")
+        cleanup_training_processes()
+        cleanup_bot_processes()
 
-@app.get("/")
-async def health(request: Request) -> response.HTTPResponse:
-    return json(
-        {
-            "status": "ok",
-            "bots": [
-                {
-                    "deployment_id": bot.deployment_id,
-                    "status": bot.status,
-                    "internal_url": bot.internal_url,
-                    "url": bot.url,
-                }
-                for bot in running_bots.values()
-            ],
-            "trainings": [
+    @bp.get("/")
+    async def health(request: Request) -> response.HTTPResponse:
+        return json(
+            {
+                "status": "ok",
+                "bots": [
+                    {
+                        "deployment_id": bot.deployment_id,
+                        "status": bot.status,
+                        "internal_url": bot.internal_url,
+                        "url": bot.url,
+                    }
+                    for bot in running_bots.values()
+                ],
+                "trainings": [
+                    {
+                        "training_id": training.training_id,
+                        "assistant_id": training.assistant_id,
+                        "client_id": training.client_id,
+                        "progress": training.progress,
+                        "status": training.status,
+                    }
+                    for training in trainings.values()
+                ],
+            }
+        )
+
+    @bp.get("/training")
+    async def get_training_list(request: Request) -> response.HTTPResponse:
+        """Return a list of all training sessions for an assistant."""
+        assistant_id = request.args.get("assistant_id")
+        sessions = [
+            {
+                "training_id": session.training_id,
+                "assistant_id": session.assistant_id,
+                "client_id": session.client_id,
+                "training_runtime": "self",
+                "status": session.status,
+                "bot_config": None,
+                "logs": None,
+                "metadata": None,
+                "model": None,
+                "runtime_metadata": None,
+            }
+            for session in trainings.values()
+            if session.assistant_id == assistant_id
+        ]
+        return json({"training_sessions": sessions, "total_number": len(sessions)})
+
+    @bp.post("/training")
+    async def start_training(request: Request) -> response.HTTPResponse:
+        """Start a new training session."""
+        data = request.json
+        training_id: Optional[str] = data.get("id")
+        assistant_id: Optional[str] = data.get("assistant_id")
+        client_id: Optional[str] = data.get("client_id")
+
+        if training_id in trainings:
+            # fail, because there apparently is already a training with this id
+            return json({"message": "Training with this id already exists"}, status=409)
+
+        if not assistant_id:
+            return json({"message": "Assistant id is required"}, status=400)
+
+        if not training_id:
+            return json({"message": "Training id is required"}, status=400)
+
+        try:
+            training_session = run_training(
+                training_id=training_id,
+                assistant_id=assistant_id,
+                client_id=client_id,
+                data=data,
+            )
+            trainings[training_id] = training_session
+            return json({"training_id": training_id})
+        except Exception as e:
+            return json({"message": str(e)}, status=500)
+
+    @bp.get("/training/<training_id>")
+    async def get_training(request: Request, training_id: str) -> response.HTTPResponse:
+        """Return the status of a training session."""
+        if training := trainings.get(training_id):
+            return json(
                 {
-                    "training_id": training.training_id,
+                    "training_id": training_id,
                     "assistant_id": training.assistant_id,
                     "client_id": training.client_id,
                     "progress": training.progress,
                     "status": training.status,
                 }
-                for training in trainings.values()
-            ],
-        }
-    )
-
+            )
+        else:
+            return json({"message": "Training not found"}, status=404)
+
+    @bp.delete("/training/<training_id>")
+    async def stop_training(
+        request: Request, training_id: str
+    ) -> response.HTTPResponse:
+        # this is a no-op if the training is already done
+        if not (training := trainings.get(training_id)):
+            return json({"message": "Training session not found"}, status=404)
 
-@app.get("/training")
-async def get_training_list(request: Request) -> response.HTTPResponse:
-    """Return a list of all training sessions for an assistant."""
-    assistant_id = request.args.get("assistant_id")
-    sessions = [
-        {
-            "training_id": session.training_id,
-            "assistant_id": session.assistant_id,
-            "client_id": session.client_id,
-            "training_runtime": "self",
-            "status": session.status,
-            "bot_config": None,
-            "logs": None,
-            "metadata": None,
-            "model": None,
-            "runtime_metadata": None,
-        }
-        for session in trainings.values()
-        if session.assistant_id == assistant_id
-    ]
-    return json({"training_sessions": sessions, "total_number": len(sessions)})
-
-
-@app.post("/training")
-async def start_training(request: Request) -> response.HTTPResponse:
-    """Start a new training session."""
-    data = request.json
-    training_id: Optional[str] = data.get("id")
-    assistant_id: Optional[str] = data.get("assistant_id")
-    client_id: Optional[str] = data.get("client_id")
-
-    if training_id in trainings:
-        # fail, because there apparently is already a training with this id
-        return json({"message": "Training with this id already exists"}, status=409)
-
-    if not assistant_id:
-        return json({"message": "Assistant id is required"}, status=400)
-
-    if not training_id:
-        return json({"message": "Training id is required"}, status=400)
-
-    try:
-        training_session = run_training(
-            training_id=training_id,
-            assistant_id=assistant_id,
-            client_id=client_id,
-            data=data,
-        )
-        trainings[training_id] = training_session
+        terminate_training(training)
         return json({"training_id": training_id})
-    except Exception as e:
-        return json({"message": str(e)}, status=500)
 
+    @bp.get("/training/<training_id>/download_url")
+    async def get_training_download_url(
+        request: Request, training_id: str
+    ) -> response.HTTPResponse:
+        # Provide a URL for downloading the training log
+        # check object key that is passed in as a query parameter
+        key = request.args.get("object_key")
+        if "model.tar.gz" in key:
+            return get_training_model_url(request, training_id)
+        return get_log_url(request, training_id)
+
+    @bp.post("/bot")
+    async def start_bot(request: Request) -> response.HTTPResponse:
+        data = request.json
+        deployment_id: Optional[str] = data.get("deployment_id")
+        assumed_model_path: Optional[str] = data.get("model_path")
+
+        if deployment_id in running_bots:
+            # fail, because there apparently is already a bot running with this id
+            return json(
+                {"message": "Bot with this deployment id already exists"}, status=409
+            )
+
+        if not deployment_id:
+            return json({"message": "Deployment id is required"}, status=400)
+
+        if not assumed_model_path:
+            return json({"message": "Model path is required"}, status=400)
+
+        training_id = assumed_model_path.split("/")[-3]
+        training_base_path = train_path(training_id)
+        if not os.path.exists(f"{training_base_path}/models"):
+            return json(
+                {"message": "Model not found, for the given training id"},
+                status=404,
+            )
+
+        base_url_path = base_server_url(request)
+        try:
+            bot_session = run_bot(deployment_id, training_base_path, base_url_path)
+            running_bots[deployment_id] = bot_session
+            return json(
+                {
+                    "deployment_id": deployment_id,
+                    "status": bot_session.status,
+                    "url": bot_session.url,
+                }
+            )
+        except Exception as e:
+            return json({"message": str(e)}, status=500)
 
-@app.get("/training/<training_id>")
-async def get_training(request: Request, training_id: str) -> response.HTTPResponse:
-    """Return the status of a training session."""
-    if training := trainings.get(training_id):
-        return json(
-            {
-                "training_id": training_id,
-                "assistant_id": training.assistant_id,
-                "client_id": training.client_id,
-                "progress": training.progress,
-                "status": training.status,
-            }
-        )
-    else:
-        return json({"message": "Training not found"}, status=404)
-
-
-@app.delete("/training/<training_id>")
-async def stop_training(request: Request, training_id: str) -> response.HTTPResponse:
-    # this is a no-op if the training is already done
-    if not (training := trainings.get(training_id)):
-        return json({"message": "Training session not found"}, status=404)
-
-    terminate_training(training)
-    return json({"training_id": training_id})
-
-
-@app.get("/training/<training_id>/download_url")
-async def get_training_download_url(
-    request: Request, training_id: str
-) -> response.HTTPResponse:
-    # Provide a URL for downloading the training log
-    # check object key that is passed in as a query parameter
-    key = request.args.get("object_key")
-    if "model.tar.gz" in key:
-        return get_training_model_url(request, training_id)
-    return get_log_url(request, training_id)
-
+    @bp.delete("/bot/<deployment_id>")
+    async def stop_bot(request: Request, deployment_id: str) -> response.HTTPResponse:
+        bot = running_bots.get(deployment_id)
+        if bot is None:
+            return json({"message": "Bot not found"}, status=404)
 
-@app.post("/bot")
-async def start_bot(request: Request) -> response.HTTPResponse:
-    data = request.json
-    deployment_id: Optional[str] = data.get("deployment_id")
-    assumed_model_path: Optional[str] = data.get("model_path")
+        terminate_bot(bot)
 
-    if deployment_id in running_bots:
-        # fail, because there apparently is already a bot running with this id
         return json(
-            {"message": "Bot with this deployment id already exists"}, status=409
+            {"deployment_id": deployment_id, "status": bot.status, "url": bot.url}
         )
 
-    if not deployment_id:
-        return json({"message": "Deployment id is required"}, status=400)
-
-    if not assumed_model_path:
-        return json({"message": "Model path is required"}, status=400)
+    @bp.get("/bot/<deployment_id>")
+    async def get_bot(request: Request, deployment_id: str) -> response.HTTPResponse:
+        bot = running_bots.get(deployment_id)
+        if bot is None:
+            return json({"message": "Bot not found"}, status=404)
 
-    training_id = assumed_model_path.split("/")[-3]
-    training_base_path = train_path(training_id)
-    if not os.path.exists(f"{training_base_path}/models"):
-        return json(
-            {"message": "Model not found, for the given training id"},
-            status=404,
-        )
-
-    base_url_path = base_server_url(request)
-    try:
-        bot_session = run_bot(deployment_id, training_base_path, base_url_path)
-        running_bots[deployment_id] = bot_session
         return json(
             {
                 "deployment_id": deployment_id,
-                "status": bot_session.status,
-                "url": bot_session.url,
+                "status": bot.status,
+                "url": bot.url,
             }
         )
-    except Exception as e:
-        return json({"message": str(e)}, status=500)
-
-
-@app.delete("/bot/<deployment_id>")
-async def stop_bot(request: Request, deployment_id: str) -> response.HTTPResponse:
-    bot = running_bots.get(deployment_id)
-    if bot is None:
-        return json({"message": "Bot not found"}, status=404)
-
-    terminate_bot(bot)
-
-    return json({"deployment_id": deployment_id, "status": bot.status, "url": bot.url})
-
-
-@app.get("/bot/<deployment_id>")
-async def get_bot(request: Request, deployment_id: str) -> response.HTTPResponse:
-    bot = running_bots.get(deployment_id)
-    if bot is None:
-        return json({"message": "Bot not found"}, status=404)
-
-    return json(
-        {
-            "deployment_id": deployment_id,
-            "status": bot.status,
-            "url": bot.url,
-        }
-    )
-
-
-@app.get("/bot/<deployment_id>/download_url")
-async def get_bot_download_url(
-    request: Request, deployment_id: str
-) -> response.HTTPResponse:
-    return get_log_url(request, deployment_id)
-
-
-@app.get("/bot/<deployment_id>/logs")
-async def get_bot_logs(request: Request, deployment_id: str) -> response.HTTPResponse:
-    return get_log_url(request, deployment_id)
-
-
-@app.get("/bot")
-async def list_bots(request: Request) -> response.HTTPResponse:
-    bots = [
-        {
-            "deployment_id": bot.deployment_id,
-            "status": bot.status,
-            "url": bot.url,
-        }
-        for bot in running_bots.values()
-    ]
-    return json({"deployment_sessions": bots, "total_number": len(bots)})
-
-
-@app.route("/logs/<path:path>")
-async def get_training_logs(request: Request, path: str) -> response.HTTPResponse:
-    try:
-        headers = {"Content-Disposition": 'attachment; filename="log.txt"'}
-        return await response.file(
-            os.path.join(logs_base_path(), path), headers=headers
-        )
-    except NotFound:
-        return json({"message": "Log not found"}, status=404)
-
-
-@app.route("/models/<path:path>")
-async def send_model(request: Request, path: str) -> response.HTTPResponse:
-    try:
-        return await response.file(models_path(path))
-    except NotFound:
-        return json({"message": "Model not found"}, status=404)
 
+    @bp.get("/bot/<deployment_id>/download_url")
+    async def get_bot_download_url(
+        request: Request, deployment_id: str
+    ) -> response.HTTPResponse:
+        return get_log_url(request, deployment_id)
+
+    @bp.get("/bot/<deployment_id>/logs")
+    async def get_bot_logs(
+        request: Request, deployment_id: str
+    ) -> response.HTTPResponse:
+        return get_log_url(request, deployment_id)
+
+    @bp.get("/bot")
+    async def list_bots(request: Request) -> response.HTTPResponse:
+        bots = [
+            {
+                "deployment_id": bot.deployment_id,
+                "status": bot.status,
+                "url": bot.url,
+            }
+            for bot in running_bots.values()
+        ]
+        return json({"deployment_sessions": bots, "total_number": len(bots)})
 
-@sio.on("connect")
-async def socketio_websocket_traffic(
-    sid: str, environ: Dict, auth: Optional[Dict]
-) -> bool:
-    """Bridge websockets between user chat socket and bot server."""
-    structlogger.debug("model_runner.user_connected", sid=sid)
-    deployment_id = auth.get("deployment_id") if auth else None
+    return bp
 
-    if deployment_id is None:
-        structlogger.error("model_runner.bot_no_deployment_id", sid=sid)
-        return False
 
-    bot = running_bots.get(deployment_id)
-    if bot is None:
-        structlogger.error("model_runner.bot_not_found", deployment_id=deployment_id)
-        return False
+def external_blueprint() -> Blueprint:
+    """Create a blueprint for the model manager API."""
+    from rasa.core.channels.socketio import SocketBlueprint
 
-    client = await create_bridge_client(sio, bot.internal_url, sid, deployment_id)
+    sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+    bp = SocketBlueprint(sio, "", "model_api_external")
 
-    if client.sid is not None:
-        structlogger.debug(
-            "model_runner.bot_connection_established", deployment_id=deployment_id
-        )
-        socket_proxy_clients[sid] = client
-        return True
-    else:
-        structlogger.error(
-            "model_runner.bot_connection_failed", deployment_id=deployment_id
+    @bp.get("/health")
+    async def health(request: Request) -> response.HTTPResponse:
+        return json(
+            {
+                "status": "ok",
+                "bots": [
+                    {
+                        "deployment_id": bot.deployment_id,
+                        "status": bot.status,
+                        "internal_url": bot.internal_url,
+                        "url": bot.url,
+                    }
+                    for bot in running_bots.values()
+                ],
+                "trainings": [
+                    {
+                        "training_id": training.training_id,
+                        "assistant_id": training.assistant_id,
+                        "client_id": training.client_id,
+                        "progress": training.progress,
+                        "status": training.status,
+                    }
+                    for training in trainings.values()
+                ],
+            }
         )
-        return False
-
-
-@sio.on("disconnect")
-async def disconnect(sid: str) -> None:
-    structlogger.debug("model_runner.bot_disconnect", sid=sid)
-    if sid in socket_proxy_clients:
-        await socket_proxy_clients[sid].disconnect()
-        del socket_proxy_clients[sid]
-
-
-@sio.on("*")
-async def handle_message(event: str, sid: str, data: Dict[str, Any]) -> None:
-    # bridge both, incoming messages to the bot_url but also
-    # send the response back to the client. both need to happen
-    # in parallel in an async way
-
-    client = socket_proxy_clients.get(sid)
-    if client is None:
-        structlogger.error("model_runner.bot_not_connected", sid=sid)
-        return
 
-    await client.emit(event, data)
+    @bp.route("/logs/<path:path>")
+    async def get_training_logs(request: Request, path: str) -> response.HTTPResponse:
+        try:
+            headers = {"Content-Disposition": 'attachment; filename="log.txt"'}
+            return await response.file(
+                os.path.join(logs_base_path(), path), headers=headers
+            )
+        except NotFound:
+            return json({"message": "Log not found"}, status=404)
+
+    @bp.route("/models/<path:path>")
+    async def send_model(request: Request, path: str) -> response.HTTPResponse:
+        try:
+            return await response.file(models_path(path))
+        except NotFound:
+            return json({"message": "Model not found"}, status=404)
+
+    @sio.on("connect")
+    async def socketio_websocket_traffic(
+        sid: str, environ: Dict, auth: Optional[Dict]
+    ) -> bool:
+        """Bridge websockets between user chat socket and bot server."""
+        structlogger.debug("model_runner.user_connected", sid=sid)
+        deployment_id = auth.get("deployment_id") if auth else None
+
+        if deployment_id is None:
+            structlogger.error("model_runner.bot_no_deployment_id", sid=sid)
+            return False
+
+        bot = running_bots.get(deployment_id)
+        if bot is None:
+            structlogger.error(
+                "model_runner.bot_not_found", deployment_id=deployment_id
+            )
+            return False
+
+        client = await create_bridge_client(sio, bot.internal_url, sid, deployment_id)
+
+        if client.sid is not None:
+            structlogger.debug(
+                "model_runner.bot_connection_established", deployment_id=deployment_id
+            )
+            socket_proxy_clients[sid] = client
+            return True
+        else:
+            structlogger.error(
+                "model_runner.bot_connection_failed", deployment_id=deployment_id
+            )
+            return False
+
+    @sio.on("disconnect")
+    async def disconnect(sid: str) -> None:
+        structlogger.debug("model_runner.bot_disconnect", sid=sid)
+        if sid in socket_proxy_clients:
+            await socket_proxy_clients[sid].disconnect()
+            del socket_proxy_clients[sid]
+
+    @sio.on("*")
+    async def handle_message(event: str, sid: str, data: Dict[str, Any]) -> None:
+        # bridge both, incoming messages to the bot_url but also
+        # send the response back to the client. both need to happen
+        # in parallel in an async way
+
+        client = socket_proxy_clients.get(sid)
+        if client is None:
+            structlogger.error("model_runner.bot_not_connected", sid=sid)
+            return
+
+        await client.emit(event, data)
+
+    return bp

rasa/model_service.py

@@ -1,9 +1,12 @@
 import os
 import logging
 
+from sanic import Sanic
 import structlog
 
+from rasa.core.utils import list_routes
 from rasa.model_manager import model_api
+from rasa.model_manager.config import SERVER_BASE_URL
 from rasa.utils.common import configure_logging_and_warnings
 import rasa.utils.licensing
 
@@ -12,6 +15,16 @@ structlogger = structlog.get_logger()
 MODEL_SERVICE_PORT = 8000
 
 
+def url_prefix_from_base_url() -> str:
+    """Return the path prefix from the base URL."""
+    if SERVER_BASE_URL:
+        from urllib.parse import urlparse
+
+        return urlparse(SERVER_BASE_URL).path
+
+    return ""
+
+
 def main() -> None:
     """Start the Rasa Model Manager server.
 
@@ -36,8 +49,17 @@ def main() -> None:
     structlogger.debug("model_training.starting_server", port=MODEL_SERVICE_PORT)
     structlogger.debug("model_running.starting_server", port=MODEL_SERVICE_PORT)
 
-    model_api.app.add_task(model_api.continuously_update_process_status)
-    model_api.app.run(host="0.0.0.0", port=MODEL_SERVICE_PORT, legacy=True)
+    url_prefix = url_prefix_from_base_url()
+    # configure the sanice application
+    app = Sanic("RasaModelService")
+    app.add_task(model_api.continuously_update_process_status)
+    app.blueprint(model_api.external_blueprint(), url_prefix=url_prefix)
+    app.blueprint(model_api.internal_blueprint())
+
+    # list all routes
+    list_routes(app)
+
+    app.run(host="0.0.0.0", port=MODEL_SERVICE_PORT, legacy=True)
 
 
 if __name__ == "__main__":

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.10.7.dev2"
+__version__ = "3.10.7.dev4"

{rasa_pro-3.10.7.dev2.dist-info → rasa_pro-3.10.7.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.10.7.dev2
+Version: 3.10.7.dev4
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework

{rasa_pro-3.10.7.dev2.dist-info → rasa_pro-3.10.7.dev4.dist-info}/RECORD

@@ -251,7 +251,7 @@ rasa/core/channels/rasa_chat.py,sha256=XGZ7QLyQHhB-m7EjetDNEBSjAa2mEFqU-e-FuS9z3
 rasa/core/channels/rest.py,sha256=zeUAKr0UyeJVt_UFfri7GAYcGzTdG-mBwwN3zLVzjpc,7129
 rasa/core/channels/rocketchat.py,sha256=HWOMxXLuwadYEYIMMP-z6RqAJzMGZDLklpgqLOipXF0,5998
 rasa/core/channels/slack.py,sha256=3b8OZQ_gih5XBwhQ1q4BbBUC1SCAPaO9AoJEn2NaoQE,24405
-rasa/core/channels/socketio.py,sha256=k0b6aWE8gqhXBaLN7Sa5qaxqrWEFqf95ZeN-fX9bhPA,10675
+rasa/core/channels/socketio.py,sha256=Lo342YwWm2O5PciEUXAXA3NRJQ5yi3ZXosRXItyzsc4,10807
 rasa/core/channels/telegram.py,sha256=XvzU7KAgjmRcu2vUJ-5L2eYAAuYBqtcYlhq1Jo6kLns,10649
 rasa/core/channels/twilio.py,sha256=c63uFLVKaK4Fj8MAn9BSQtxiV_Ezq4POezHo8zWIoiw,5938
 rasa/core/channels/twilio_voice.py,sha256=SrtNZOk3Yuk_QuUk45Hadj3PGvmwD0jeSzF90GbiUV0,13244
@@ -484,12 +484,12 @@ rasa/markers/validate.py,sha256=YypXKRS87xxrMMEz9HpAQzYJUwg0OPbczMXBRNjlJq4,709
 rasa/model.py,sha256=GH1-N6Po3gL3nwfa9eGoN2bMRNMrn4f3mi17-osW3T0,3491
 rasa/model_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rasa/model_manager/config.py,sha256=LCzRoV78bLX_FREW7hfQLsQepupoTs1m-CnK3u_D01s,349
-rasa/model_manager/model_api.py,sha256=Eoq6TBjYaqB-9arLIH1Uz_pb7ZagQ8qYDkUAx6DDARE,13926
+rasa/model_manager/model_api.py,sha256=2c0JL-tWn7ayn2EjVes-2tVQHj_FzULmpYC7IpOSJEI,16261
 rasa/model_manager/runner_service.py,sha256=aMupR7t0EEy2yOGT5cR_6kluApnwOiiGkjyIVYxdsMk,5553
 rasa/model_manager/socket_bridge.py,sha256=f-dhsV8xYaENXVZT5OOzkMdpSPPPxFEzsQqNJAuktxQ,1390
 rasa/model_manager/trainer_service.py,sha256=7LP_EsLQt-P2oqO1AgqbgIcTC515eCW58BamDkDjJjw,7856
 rasa/model_manager/utils.py,sha256=-DJUcgRiyQZsszlOYlww-OGaAof8CIopbsOxZmeZ9NY,819
-rasa/model_service.py,sha256=ZULb8jJHPQYIWtMVv5cCYExJdBnAFs4Wv89p1bVGzqo,1212
+rasa/model_service.py,sha256=x6vFrxc_VH8dh1I5Tkw2cbUimbqoxpiFQKpcem9tSg8,1818
 rasa/model_testing.py,sha256=h0QUpJu6p_TDse3aHjCfYwI6OGH47b3Iuo5Ot0HQADM,14959
 rasa/model_training.py,sha256=sFdrizWu8JZZDGrMjI6_0OaY9dK-msOShWpgOOCGZzg,20601
 rasa/nlu/__init__.py,sha256=D0IYuTK_ZQ_F_9xsy0bXxVCAtU62Fzvp8S7J9tmfI_c,123
@@ -727,9 +727,9 @@ rasa/utils/train_utils.py,sha256=f1NWpp5y6al0dzoQyyio4hc4Nf73DRoRSHDzEK6-C4E,212
 rasa/utils/url_tools.py,sha256=JQcHL2aLqLHu82k7_d9imUoETCm2bmlHaDpOJ-dKqBc,1218
 rasa/utils/yaml.py,sha256=KjbZq5C94ZP7Jdsw8bYYF7HASI6K4-C_kdHfrnPLpSI,2000
 rasa/validator.py,sha256=HM0ZIWjo3JRt2FMIfgNI_s932OABOSXkflm-rFTNkvY,62608
-rasa/version.py,sha256=_xRWomNdCH1OVLVcaYC_a-LVDeKGrYo4iDznhzakf3k,122
-rasa_pro-3.10.7.dev2.dist-info/METADATA,sha256=exaKQ2A81Kk0kydkgvN3ipZyApPtmatZ96AU2LhlpIo,28217
-rasa_pro-3.10.7.dev2.dist-info/NOTICE,sha256=7HlBoMHJY9CL2GlYSfTQ-PZsVmLmVkYmMiPlTjhuCqA,218
-rasa_pro-3.10.7.dev2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-rasa_pro-3.10.7.dev2.dist-info/entry_points.txt,sha256=ckJ2SfEyTPgBqj_I6vm_tqY9dZF_LAPJZA335Xp0Q9U,43
-rasa_pro-3.10.7.dev2.dist-info/RECORD,,
+rasa/version.py,sha256=8PjlwS5fwFAp76cEyd2sO2WTKsD27O3oI34eANowHJQ,122
+rasa_pro-3.10.7.dev4.dist-info/METADATA,sha256=XPkuyA-6VxXeaHYLP43ku28tp_o9KSlk6WpxvpBRTSw,28217
+rasa_pro-3.10.7.dev4.dist-info/NOTICE,sha256=7HlBoMHJY9CL2GlYSfTQ-PZsVmLmVkYmMiPlTjhuCqA,218
+rasa_pro-3.10.7.dev4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+rasa_pro-3.10.7.dev4.dist-info/entry_points.txt,sha256=ckJ2SfEyTPgBqj_I6vm_tqY9dZF_LAPJZA335Xp0Q9U,43
+rasa_pro-3.10.7.dev4.dist-info/RECORD,,