rasa-pro 3.13.1a13__py3-none-any.whl → 3.13.1a15__py3-none-any.whl

rasa/builder/config.py

@@ -43,13 +43,18 @@ def get_default_config(assistant_id: str) -> Dict[str, Any]:
             )
         )
     )
+
+    if not isinstance(base_config, dict):
+        raise ValueError("Base config is not a dictionary")
+
     base_config["assistant_id"] = assistant_id
+
     return base_config
 
 
 def get_default_endpoints() -> Dict[str, Any]:
     """Get default endpoints configuration."""
-    return read_yaml_file(
+    endpoints_config = read_yaml_file(
         str(
             importlib_resources.files(PACKAGE_NAME).joinpath(
                 "cli/project_templates/default/endpoints.yml"
@@ -57,6 +62,11 @@ def get_default_endpoints() -> Dict[str, Any]:
         )
     )
 
+    if not isinstance(endpoints_config, dict):
+        raise ValueError("Endpoints config is not a dictionary")
+
+    return endpoints_config
+
 
 def get_default_credentials() -> Dict[str, Any]:
     """Get default credentials configuration."""

rasa/builder/llm_service.py

@@ -5,7 +5,7 @@ import importlib
 import json
 from contextlib import asynccontextmanager
 from copy import deepcopy
-from typing import Any, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, List, Optional
 
 import importlib_resources
 import openai
@@ -28,14 +28,14 @@ structlogger = structlog.get_logger()
 class LLMService:
     """Handles OpenAI LLM interactions with caching for efficiency."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._client: Optional[openai.AsyncOpenAI] = None
         self._domain_schema: Optional[Dict[str, Any]] = None
         self._flows_schema: Optional[Dict[str, Any]] = None
         self._helper_schema: Optional[Dict[str, Any]] = None
 
     @asynccontextmanager
-    async def _get_client(self):
+    async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
         """Get or create OpenAI client with proper resource management."""
         if self._client is None:
             self._client = openai.AsyncOpenAI(timeout=config.OPENAI_TIMEOUT)
@@ -46,7 +46,7 @@ class LLMService:
             structlogger.error("llm.client_error", error=str(e))
             raise
 
-    def _prepare_schemas(self):
+    def _prepare_schemas(self) -> None:
         """Prepare and cache schemas for LLM generation."""
         if self._domain_schema is None:
             self._domain_schema = _prepare_domain_schema()
@@ -192,7 +192,7 @@ class LLMService:
             return []
 
     @staticmethod
-    def _format_chat_dump(messages) -> str:
+    def _format_chat_dump(messages: List[Dict[str, Any]]) -> str:
         """Format chat messages for documentation search."""
         result = ""
         for message in messages:
@@ -213,7 +213,7 @@ class LLMService:
         return result
 
     @staticmethod
-    def _format_documentation_results(results) -> str:
+    def _format_documentation_results(results: List[Dict[str, Any]]) -> str:
         """Format documentation search results."""
         if not results:
             return "<sources>No relevant documentation found.</sources>"
@@ -233,6 +233,9 @@ def _prepare_domain_schema() -> Dict[str, Any]:
     """Prepare domain schema by removing unnecessary parts."""
     domain_schema = deepcopy(read_schema_file(DOMAIN_SCHEMA_FILE, PACKAGE_NAME, False))
 
+    if not isinstance(domain_schema, dict):
+        raise ValueError("Domain schema is not a dictionary")
+
     # Remove parts not needed for CALM bots
     unnecessary_keys = ["intents", "entities", "forms", "config", "session_config"]
 

rasa/builder/main.py

@@ -5,13 +5,23 @@ import logging
 import sys
 from typing import Optional
 
+import structlog
+from sanic import HTTPResponse, Sanic
+from sanic.request import Request
+from sanic_openapi import openapi3_blueprint
+
 import rasa.core.utils
+from rasa.builder import config
 from rasa.builder.logging_utils import collecting_logs_processor
-from rasa.builder.service import BotBuilderService
+from rasa.builder.service import bp, setup_project_generator
+from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.server import configure_cors
 from rasa.utils.common import configure_logging_and_warnings
 from rasa.utils.log_utils import configure_structlog
 from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
+structlogger = structlog.get_logger()
+
 
 def setup_logging() -> None:
     """Setup logging configuration."""
@@ -31,22 +41,98 @@ def setup_logging() -> None:
     )
 
 
+def setup_input_channel() -> StudioChatInput:
+    """Setup the input channel for chat interactions."""
+    studio_chat_credentials = config.get_default_credentials().get(
+        StudioChatInput.name()
+    )
+    return StudioChatInput.from_credentials(credentials=studio_chat_credentials)
+
+
+def setup_middleware(app: Sanic) -> None:
+    """Setup middleware for request/response processing."""
+
+    @app.middleware("request")
+    async def log_request(request: Request) -> None:
+        structlogger.info(
+            "request.received",
+            method=request.method,
+            path=request.path,
+            remote_addr=request.remote_addr or "unknown",
+        )
+
+    @app.middleware("response")
+    async def log_response(request: Request, response: HTTPResponse) -> None:
+        structlogger.info(
+            "request.completed",
+            method=request.method,
+            path=request.path,
+            status=response.status,
+        )
+
+
+def create_app(project_folder: Optional[str] = None) -> Sanic:
+    """Create and configure the Sanic app."""
+    app = Sanic("BotBuilderService")
+
+    # Basic app configuration
+    app.config.REQUEST_TIMEOUT = 60  # 1 minute timeout
+    app.ctx.agent = None
+
+    # Set up project generator and store in app context
+    app.ctx.project_generator = setup_project_generator(project_folder)
+
+    # Set up input channel and store in app context
+    app.ctx.input_channel = setup_input_channel()
+
+    # Register the blueprint
+    app.blueprint(bp)
+
+    # OpenAPI docs
+    app.blueprint(openapi3_blueprint)
+    app.config.API_TITLE = "Bot Builder API"
+    app.config.API_VERSION = rasa.__version__
+    app.config.API_DESCRIPTION = (
+        "API for building conversational AI bots from prompts and templates. "
+        "The API allows to change the assistant and retrain it with new data."
+    )
+
+    # Setup middleware
+    setup_middleware(app)
+
+    configure_cors(app, cors_origins=config.CORS_ORIGINS)
+
+    # Register input channel webhooks
+    from rasa.core import channels
+
+    channels.channel.register([app.ctx.input_channel], app, route="/webhooks/")
+
+    return app
+
+
 def main(project_folder: Optional[str] = None) -> None:
     """Main entry point."""
     try:
         # Setup logging
         setup_logging()
 
-        # Create and configure service
-
-        service = BotBuilderService(project_folder)
-        register_custom_sanic_error_handler(service.app)
-
-        # Log available routes
-        rasa.core.utils.list_routes(service.app)
+        # Create and configure app
+        app = create_app(project_folder)
+        register_custom_sanic_error_handler(app)
 
         # Run the service
-        service.run()
+        structlogger.info(
+            "service.starting",
+            host=config.BUILDER_SERVER_HOST,
+            port=config.BUILDER_SERVER_PORT,
+        )
+
+        app.run(
+            host=config.BUILDER_SERVER_HOST,
+            port=config.BUILDER_SERVER_PORT,
+            legacy=True,
+            motd=False,
+        )
 
     except KeyboardInterrupt:
         print("\nService stopped by user")

rasa/builder/models.py

@@ -19,7 +19,7 @@ class PromptRequest(BaseModel):
     )
 
     @validator("prompt")
-    def validate_prompt(cls, v):
+    def validate_prompt(cls, v: str) -> str:
         if not v.strip():
             raise ValueError("Prompt cannot be empty or whitespace only")
         return v.strip()
@@ -39,7 +39,7 @@ class TemplateRequest(BaseModel):
     )
 
     @validator("template_name")
-    def validate_template_name(cls, v):
+    def validate_template_name(cls, v: Any) -> Any:
         if v not in ProjectTemplateName:
             raise ValueError(
                 f"Template name must be one of {ProjectTemplateName.supported_values()}"

rasa/builder/project_generator.py

@@ -25,7 +25,7 @@ structlogger = structlog.get_logger()
 class ProjectGenerator:
     """Service for generating Rasa projects from skill descriptions."""
 
-    def __init__(self, project_folder: str):
+    def __init__(self, project_folder: str) -> None:
         """Initialize the project generator with a folder for file persistence.
 
         Args:
@@ -34,7 +34,7 @@ class ProjectGenerator:
         self.project_folder = Path(project_folder)
         self.project_folder.mkdir(parents=True, exist_ok=True)
 
-    def init_from_template(self, template: ProjectTemplateName):
+    def init_from_template(self, template: ProjectTemplateName) -> None:
         """Create the initial project files."""
         self.cleanup()
         create_initial_project(self.project_folder.as_posix(), template)
@@ -150,7 +150,7 @@ class ProjectGenerator:
 
         return await _generate_with_retry(initial_messages, max_retries)
 
-    async def _validate_generated_project(self):
+    async def _validate_generated_project(self) -> None:
         """Validate the generated project using the validation service."""
         importer = self._create_importer()
         validation_error = await validate_project(importer)
@@ -180,7 +180,7 @@ class ProjectGenerator:
 
     def get_bot_files(self) -> Dict[str, Optional[str]]:
         """Get the current bot files by reading from disk."""
-        bot_files = {}
+        bot_files: Dict[str, Optional[str]] = {}
 
         for file in self.project_folder.glob("**/*"):
             # Skip directories
@@ -255,7 +255,7 @@ class ProjectGenerator:
             shutil.rmtree(flows_folder)
         flows_folder.mkdir(parents=True, exist_ok=True)
 
-    def update_bot_files(self, files: Dict[str, str]) -> None:
+    def update_bot_files(self, files: Dict[str, Optional[str]]) -> None:
         """Update bot files with new content by writing to disk."""
         for filename, content in files.items():
             file_path = Path(subpath(self.project_folder, filename))

rasa/builder/scrape_rasa_docs.py

@@ -17,18 +17,18 @@ to_visit = [DOCS_ROOT]
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 
-def is_valid_doc_url(url):
+def is_valid_doc_url(url: str) -> bool:
     return url.startswith(DOCS_ROOT) and not any(
         [url.endswith(".pdf"), "#" in url, "mailto:" in url]
     )
 
 
-def slugify_url(url):
+def slugify_url(url: str) -> str:
     path = urlparse(url).path.strip("/").replace("/", "_")
     return path if path else "index"
 
 
-def clean_text(html):
+def clean_text(html: str) -> str:
     soup = BeautifulSoup(html, "html.parser")
 
     # Remove navs, footers, and code tabs (customize if needed)
@@ -47,7 +47,7 @@ def clean_text(html):
     return text
 
 
-def save_as_markdown(text) -> str:
+def save_as_markdown(text: str, url: str) -> str:
     slug = slugify_url(url)
     file_name = f"{slug}.md"
     md_path = Path(OUTPUT_DIR) / file_name