rasa-pro 3.13.1a18__py3-none-any.whl → 3.13.2__py3-none-any.whl

rasa/builder/models.py

@@ -1,225 +0,0 @@
-"""Pydantic models for request/response validation."""
-
-from typing import Any, Dict, List, Literal, Optional, Union
-
-from pydantic import BaseModel, Field, validator
-
-from rasa.cli.scaffold import ProjectTemplateName
-from rasa.shared.core.trackers import DialogueStateTracker
-
-
-class PromptRequest(BaseModel):
-    """Request model for prompt-to-bot endpoint."""
-
-    prompt: str = Field(
-        ..., min_length=1, max_length=10000, description="The skill description prompt"
-    )
-    client_id: Optional[str] = Field(
-        None, max_length=255, description="Optional client identifier"
-    )
-
-    @validator("prompt")
-    def validate_prompt(cls, v: str) -> str:
-        if not v.strip():
-            raise ValueError("Prompt cannot be empty or whitespace only")
-        return v.strip()
-
-
-class TemplateRequest(BaseModel):
-    """Request model for template-to-bot endpoint."""
-
-    template_name: ProjectTemplateName = Field(
-        ...,
-        description=(
-            f"The template name to use ({ProjectTemplateName.supported_values()})"
-        ),
-    )
-    client_id: Optional[str] = Field(
-        None, max_length=255, description="Optional client identifier"
-    )
-
-    @validator("template_name")
-    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()}"
-            )
-        return v
-
-
-class ChatMessage(BaseModel):
-    """Model for chat messages."""
-
-    type: str = Field(..., pattern="^(user|assistant)$")
-    content: Union[str, List[Dict[str, Any]]] = Field(...)
-
-
-class LLMBuilderRequest(BaseModel):
-    """Request model for LLM builder endpoint."""
-
-    messages: List[ChatMessage] = Field(..., min_items=1, max_items=50)
-
-
-class LLMBuilderContext(BaseModel):
-    """Context model for LLM builder endpoint."""
-
-    tracker: Optional[DialogueStateTracker] = Field(None)
-    bot_logs: str = Field("")
-    chat_bot_files: Dict[str, str] = Field({})
-    chat_history: List[ChatMessage] = Field([])
-
-    class Config:
-        """Config for LLMBuilderContext."""
-
-        arbitrary_types_allowed = True
-
-
-class BotDataUpdateRequest(BaseModel):
-    """Request model for bot data updates."""
-
-    domain_yml: Optional[str] = Field(None, alias="domain.yml")
-    flows_yml: Optional[str] = Field(None, alias="flows.yml")
-    config_yml: Optional[str] = Field(None, alias="config.yml")
-
-    class Config:
-        """Config for BotDataUpdateRequest."""
-
-        allow_population_by_field_name = True
-
-
-class ContentBlock(BaseModel):
-    """Base model for content blocks."""
-
-    type: str = Field(...)
-
-
-class TextBlock(ContentBlock):
-    """Text content block."""
-
-    type: Literal["text"] = "text"
-    text: str = Field(...)
-
-
-class CodeBlock(ContentBlock):
-    """Code content block."""
-
-    type: Literal["code"] = "code"
-    text: str = Field(...)
-    language: Optional[str] = Field(None)
-
-
-class FileBlock(ContentBlock):
-    """File content block."""
-
-    type: Literal["file"] = "file"
-    file: str = Field(...)
-    content: str = Field(...)
-
-
-class LinkBlock(ContentBlock):
-    """Link content block."""
-
-    type: Literal["link"] = "link"
-    text: str = Field(..., pattern=r"^https?://")
-
-
-class LLMHelperResponse(BaseModel):
-    """Response model for LLM helper."""
-
-    content_blocks: List[Union[TextBlock, CodeBlock, FileBlock, LinkBlock]] = Field(...)
-
-
-class ApiErrorResponse(BaseModel):
-    """API error response model."""
-
-    status: Literal["error"] = "error"
-    error: str = Field(...)
-    details: Optional[Dict[str, Any]] = Field(None)
-
-
-class ServerSentEvent(BaseModel):
-    """Server-sent event model."""
-
-    event: str = Field(...)
-    data: Dict[str, Any] = Field(...)
-
-    def format(self) -> str:
-        """Format as SSE string."""
-        import json
-
-        return f"event: {self.event}\ndata: {json.dumps(self.data)}\n\n"
-
-
-class ValidationResult(BaseModel):
-    """Result of validation operation."""
-
-    is_valid: bool = Field(...)
-    errors: Optional[List[str]] = Field(None)
-    warnings: Optional[List[str]] = Field(None)
-
-
-class TrainingResult(BaseModel):
-    """Result of training operation."""
-
-    success: bool = Field(...)
-    model_path: Optional[str] = Field(None)
-    error: Optional[str] = Field(None)
-
-
-BotFiles = Dict[str, Optional[str]]
-
-
-class Document(BaseModel):
-    """Model for document retrieval results."""
-
-    content: str = Field(...)
-    url: Optional[str] = Field(None)
-    title: Optional[str] = Field(None)
-    metadata: Optional[Dict[str, Any]] = Field(None)
-
-    @classmethod
-    def from_inkeep_rag_response(cls, rag_item: Dict[str, Any]) -> "Document":
-        """Create a Document object from a single InKeep RAG response item.
-
-        Args:
-            rag_item: Single item from InKeep RAG response
-
-        Returns:
-            Document object with extracted content and metadata
-        """
-        source = rag_item.get("source", {})
-        text_content = cls._extract_text_from_source(source)
-
-        return cls(
-            content=text_content.strip() if text_content else "",
-            url=rag_item.get("url"),
-            title=rag_item.get("title"),
-            metadata={
-                "type": rag_item.get("type"),
-                "record_type": rag_item.get("record_type"),
-                "context": rag_item.get("context"),
-                "media_type": source.get("media_type"),
-            },
-        )
-
-    @staticmethod
-    def _extract_text_from_source(source: Dict[str, Any]) -> str:
-        """Extract text content from InKeep source object.
-
-        Args:
-            source: Source object from InKeep RAG response
-
-        Returns:
-            Extracted text content
-        """
-        # Try to extract from content array first
-        if "content" in source:
-            text_parts = []
-            for content_item in source["content"]:
-                if content_item.get("type") == "text" and content_item.get("text"):
-                    text_parts.append(content_item["text"])
-            if text_parts:
-                return "\n".join(text_parts)
-
-        # Fallback to source data
-        return source.get("data", "")

rasa/builder/project_generator.py

@@ -1,282 +0,0 @@
-"""Service for generating Rasa projects from prompts."""
-
-import json
-import os
-import shutil
-from pathlib import Path
-from textwrap import dedent
-from typing import Any, Dict, List, Optional
-
-import structlog
-
-from rasa.builder import config
-from rasa.builder.exceptions import ProjectGenerationError, ValidationError
-from rasa.builder.llm_service import get_skill_generation_messages, llm_service
-from rasa.builder.models import BotFiles
-from rasa.builder.validation_service import validate_project
-from rasa.cli.scaffold import ProjectTemplateName, create_initial_project
-from rasa.shared.core.flows import yaml_flows_io
-from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
-from rasa.utils.io import subpath
-
-structlogger = structlog.get_logger()
-
-
-class ProjectGenerator:
-    """Service for generating Rasa projects from skill descriptions."""
-
-    def __init__(self, project_folder: str) -> None:
-        """Initialize the project generator with a folder for file persistence.
-
-        Args:
-            project_folder: Path to the folder where project files will be stored
-        """
-        self.project_folder = Path(project_folder)
-        self.project_folder.mkdir(parents=True, exist_ok=True)
-
-    def init_from_template(self, template: ProjectTemplateName) -> None:
-        """Create the initial project files."""
-        self.cleanup()
-        create_initial_project(self.project_folder.as_posix(), template)
-
-    async def generate_project_with_retries(
-        self,
-        skill_description: str,
-        template: ProjectTemplateName,
-        max_retries: Optional[int] = None,
-    ) -> Dict[str, Optional[str]]:
-        """Generate a Rasa project with retry logic for validation failures.
-
-        Args:
-            skill_description: Natural language description of the skill
-            rasa_config: Rasa configuration dictionary
-            template: Project template to use for the initial project
-            max_retries: Maximum number of retry attempts
-
-        Returns:
-            Dictionary of generated file contents (filename -> content)
-
-        Raises:
-            ProjectGenerationError: If generation fails after all retries
-        """
-        if max_retries is None:
-            max_retries = config.MAX_RETRIES
-
-        self.init_from_template(template)
-
-        project_data = self._get_bot_data_for_llm()
-
-        initial_messages = get_skill_generation_messages(
-            skill_description, project_data
-        )
-
-        async def _generate_with_retry(
-            messages: List[Dict[str, Any]], attempts_left: int
-        ) -> Dict[str, Optional[str]]:
-            try:
-                # Generate project data using LLM
-                project_data = await llm_service.generate_rasa_project(messages)
-
-                # Update stored bot data
-                self._update_bot_files_from_llm_response(project_data)
-
-                bot_files = self.get_bot_files()
-                structlogger.info(
-                    "project_generator.generated_project",
-                    attempts_left=attempts_left,
-                    files=list(bot_files.keys()),
-                )
-
-                # Validate the generated project
-                await self._validate_generated_project()
-
-                structlogger.info(
-                    "project_generator.validation_success", attempts_left=attempts_left
-                )
-
-                return bot_files
-
-            except ValidationError as e:
-                structlogger.error(
-                    "project_generator.validation_error",
-                    error=str(e),
-                    attempts_left=attempts_left,
-                )
-
-                if attempts_left <= 0:
-                    raise ProjectGenerationError(
-                        f"Failed to generate valid Rasa project: {e}", max_retries
-                    )
-
-                # Create error feedback for next attempt
-                error_feedback_messages = messages + [
-                    {
-                        "role": "assistant",
-                        "content": json.dumps(project_data),
-                    },
-                    {
-                        "role": "user",
-                        "content": dedent(f"""
-                            Previous attempt failed validation with error: {e}
-
-                            Please fix the issues and generate a valid Rasa project.
-                            Pay special attention to:
-                            - Proper YAML syntax
-                            - Required fields in domain and flows
-                            - Consistent naming between flows and domain
-                            - Valid slot types and mappings
-                        """).strip(),
-                    },
-                ]
-
-                return await _generate_with_retry(
-                    error_feedback_messages, attempts_left - 1
-                )
-
-            except Exception as e:
-                structlogger.error(
-                    "project_generator.generation_error",
-                    error=str(e),
-                    attempts_left=attempts_left,
-                )
-
-                if attempts_left <= 0:
-                    raise ProjectGenerationError(
-                        f"Failed to generate Rasa project: {e}", max_retries
-                    )
-
-                # For non-validation errors, retry with original messages
-                return await _generate_with_retry(initial_messages, attempts_left - 1)
-
-        return await _generate_with_retry(initial_messages, max_retries)
-
-    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)
-
-        if validation_error:
-            raise ValidationError(validation_error)
-
-    def _create_importer(self) -> TrainingDataImporter:
-        """Create a training data importer from the current bot files."""
-        try:
-            if (self.project_folder / "domain.yml").exists():
-                domain_path = self.project_folder / "domain.yml"
-            else:
-                domain_path = self.project_folder / "domain"
-
-            return TrainingDataImporter.load_from_config(
-                config_path=self.project_folder / "config.yml",
-                domain_path=domain_path,
-                training_data_paths=[
-                    self.project_folder / "data",
-                ],
-                args={},
-            )
-
-        except Exception as e:
-            raise ValidationError(f"Failed to create importer: {e}")
-
-    def get_bot_files(self) -> BotFiles:
-        """Get the current bot files by reading from disk."""
-        bot_files: BotFiles = {}
-
-        for file in self.project_folder.glob("**/*"):
-            # Skip directories
-            if not file.is_file():
-                continue
-
-            relative_path = file.relative_to(self.project_folder)
-
-            # Skip hidden files and directories (any path component starting with '.')
-            # as well as `__pycache__` folders
-            if any(part.startswith(".") for part in relative_path.parts):
-                continue
-
-            if "__pycache__" in relative_path.parts:
-                continue
-
-            # exclude the project_folder / models folder
-            if relative_path.parts[0] == "models":
-                continue
-
-            # Read file content and store with relative path as key
-            try:
-                bot_files[relative_path.as_posix()] = file.read_text(encoding="utf-8")
-            except Exception as e:
-                structlogger.debug(
-                    "project_generator.get_bot_files.error",
-                    error=str(e),
-                    file_path=file.as_posix(),
-                )
-                bot_files[relative_path.as_posix()] = None
-
-        return bot_files
-
-    def _get_bot_data_for_llm(self) -> Dict[str, Any]:
-        """Get the current bot data for the LLM."""
-        file_importer = self._create_importer()
-
-        # only include data created by the user (or the builder llm)
-        # avoid including to many defaults that are not customized
-        domain = file_importer.get_user_domain()
-        flows = file_importer.get_user_flows()
-
-        return {
-            "domain": domain.as_dict(should_clean_json=True),
-            "flows": yaml_flows_io.get_flows_as_json(flows, should_clean_json=True),
-        }
-
-    def _path_for_flow(self, flow_id: str) -> str:
-        """Get the path for a flow."""
-        if flow_id.startswith("pattern_"):
-            return f"data/patterns/{flow_id}.yml"
-        else:
-            return f"data/flows/{flow_id}.yml"
-
-    def _update_bot_files_from_llm_response(self, project_data: Dict[str, Any]) -> None:
-        """Update the bot files with generated data by writing to disk."""
-        files = {"domain.yml": dump_obj_as_yaml_to_string(project_data["domain"])}
-        # split up flows into one file per flow in the /flows folder
-        for flow_id, flow_data in project_data["flows"].get("flows", {}).items():
-            flow_file_path = self._path_for_flow(flow_id)
-            single_flow_file_data = {"flows": {flow_id: flow_data}}
-            files[flow_file_path] = dump_obj_as_yaml_to_string(single_flow_file_data)
-
-        # removes any other flows that the LLM didn't generate
-        self._cleanup_flows()
-        self.update_bot_files(files)
-
-    def _cleanup_flows(self) -> None:
-        """Cleanup the flows folder."""
-        flows_folder = self.project_folder / "data" / "flows"
-        if flows_folder.exists():
-            shutil.rmtree(flows_folder)
-        flows_folder.mkdir(parents=True, exist_ok=True)
-
-    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))
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-            file_path.write_text(content, encoding="utf-8")
-
-    def cleanup(self) -> None:
-        """Cleanup the project folder."""
-        # remove all the files and folders in the project folder resulting
-        # in an empty folder
-        for filename in os.listdir(self.project_folder):
-            file_path = os.path.join(self.project_folder, filename)
-            try:
-                if os.path.isfile(file_path) or os.path.islink(file_path):
-                    os.unlink(file_path)
-                elif os.path.isdir(file_path):
-                    shutil.rmtree(file_path)
-            except Exception as e:
-                structlogger.error(
-                    "project_generator.cleanup_error",
-                    error=str(e),
-                    file_path=file_path,
-                )

rasa/builder/scrape_rasa_docs.py

@@ -1,97 +0,0 @@
-import json
-import os
-from pathlib import Path
-from urllib.parse import urljoin, urlparse
-
-import requests
-from bs4 import BeautifulSoup
-
-BASE_URL = "https://rasa.com"
-DOCS_ROOT = "https://rasa.com/docs"
-OUTPUT_DIR = "rasa_docs_md"
-MAX_PAGES = 100  # Optional limit for safety
-
-visited = set()
-to_visit = [DOCS_ROOT]
-
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-
-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: str) -> str:
-    path = urlparse(url).path.strip("/").replace("/", "_")
-    return path if path else "index"
-
-
-def clean_text(html: str) -> str:
-    soup = BeautifulSoup(html, "html.parser")
-
-    # Remove navs, footers, and code tabs (customize if needed)
-    for tag in soup(["nav", "footer", "script", "style", "form", "button"]):
-        tag.decompose()
-
-    main = soup.find("main") or soup.body
-    if not main:
-        return ""
-
-    # Replace <code> with backticks
-    for code in main.find_all("code"):
-        code.string = f"`{code.get_text(strip=True)}`"
-
-    text = main.get_text(separator="\n", strip=True)
-    return text
-
-
-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
-    with open(md_path, "w", encoding="utf-8") as f:
-        f.write(text)
-
-    print(f"✅ Saved: {md_path}")
-    return file_name
-
-
-pages_scraped = 0
-markdown_to_url = {}
-
-while to_visit and pages_scraped < MAX_PAGES:
-    url = to_visit.pop(0)
-    if url in visited:
-        continue
-
-    try:
-        print(f"Scraping: {url}")
-        response = requests.get(url)
-        response.raise_for_status()
-
-        html = response.text
-        text = clean_text(html)
-        if len(text) < 200:  # skip very short pages
-            print("⏭️ Skipped (too short)")
-            continue
-
-        file_name = save_as_markdown(text)
-        markdown_to_url[file_name] = url
-        pages_scraped += 1
-
-        soup = BeautifulSoup(html, "html.parser")
-        for link_tag in soup.find_all("a", href=True):
-            link = urljoin(url, link_tag["href"])
-            if is_valid_doc_url(link) and link not in visited:
-                to_visit.append(link)
-
-        visited.add(url)
-
-    except Exception as e:
-        print(f"⚠️ Failed to scrape {url}: {e}")
-
-
-with open("markdown_to_url.json", "w") as f:
-    json.dump(markdown_to_url, f, indent=2)