ai-parrot 0.17.2__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

parrot/exceptions.pxd

@@ -0,0 +1,22 @@
+# cython: language_level=3, embedsignature=True, boundscheck=False, wraparound=True, initializedcheck=False
+# Copyright (C) 2018-present Jesus Lara
+
+cdef class ParrotError(Exception):
+    cdef object message
+    cdef object stacktrace
+
+cdef class ConfigError(ParrotError):
+    pass
+
+cdef class SpeechGenerationError(ParrotError):
+    """Capture Errors related to speech generation."""
+    pass
+
+
+cdef class DriverError(ParrotError):
+    """Capture Errors related to driver operations."""
+    pass
+
+cdef class ToolError(ParrotError):
+    """Capture Errors related to tool operations."""
+    pass

parrot/exceptions.pxi

@@ -0,0 +1,15 @@
+# parrot/exceptions.pyi
+from typing import Any, Optional
+
+class ParrotError(Exception):
+    message: Any
+    stacktrace: Optional[Any]
+    def __init__(self, message: Any, *args, **kwargs) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def get(self) -> Any: ...
+
+class ConfigError(ParrotError): ...
+class SpeechGenerationError(ParrotError): ...
+class DriverError(ParrotError): ...
+class ToolError(ParrotError): ...

parrot/exceptions.pyx

@@ -0,0 +1,44 @@
+# cython: language_level=3, embedsignature=True, boundscheck=False, wraparound=True, initializedcheck=False
+# Copyright (C) 2018-present Jesus Lara
+#
+cdef class ParrotError(Exception):
+    """Base class for other exceptions"""
+
+    def __init__(self, object message, *args, **kwargs):
+        super().__init__(message)
+        if hasattr(message, 'message'):
+            self.message = message.message
+        else:
+            self.message = str(message)
+        self.stacktrace = None
+        if 'stacktrace' in kwargs:
+            self.stacktrace = kwargs['stacktrace']
+        self.args = kwargs
+
+    def __repr__(self):
+        return f"{self.message}"
+
+    def __str__(self):
+        return f"{self.message}"
+
+    def get(self):
+        """Return the message of the exception."""
+        return self.message
+
+
+cdef class ConfigError(ParrotError):
+    pass
+
+
+cdef class SpeechGenerationError(ParrotError):
+    """Capture Errors related to speech generation."""
+    pass
+
+
+cdef class DriverError(ParrotError):
+    """Capture Errors related to driver operations."""
+    pass
+
+cdef class ToolError(ParrotError):
+    """Capture Errors related to tool operations."""
+    pass

parrot/generators/__init__.py

@@ -0,0 +1,29 @@
+"""
+Web App Generator Implementation for AI-Parrot
+========================================================
+
+This module provides generators for creating full web applications with LLMs.
+
+Directory structure to create:
+parrot/
+├── generators/
+│   ├── __init__.py          # This file
+│   ├── base.py              # Base generator class
+│   ├── streamlit.py         # Streamlit generator
+│   ├── react.py             # React generator
+│   └── html.py              # HTML/JS generator
+"""
+from .base import WebAppGenerator
+from .streamlit import StreamlitGenerator, StreamlitApp
+from .react import ReactGenerator, ReactApp
+from .html import HTMLGenerator, HTMLApp
+
+__all__ = [
+    'WebAppGenerator',
+    'StreamlitGenerator',
+    'StreamlitApp',
+    'ReactGenerator',
+    'ReactApp',
+    'HTMLGenerator',
+    'HTMLApp'
+]

parrot/generators/base.py

@@ -0,0 +1,200 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Type, Dict, Any, Union
+import datetime
+from pathlib import Path
+from pydantic import BaseModel
+from navconfig.logging import logging
+from ..models.responses import AIMessage
+
+
+class WebAppGenerator(ABC):
+    """
+    Base class for web application generators.
+
+    Subclass this to create generators for specific app types (Streamlit, React, etc.)
+    """
+
+    def __init__(
+        self,
+        llm_client,
+        output_dir: Optional[Path] = None
+    ):
+        """
+        Initialize the generator.
+
+        Args:
+            llm_client: LLM client instance (GoogleClient, OpenAIClient, etc.)
+            output_dir: Optional directory to save generated apps
+        """
+        self.llm = llm_client
+        self.output_dir = output_dir
+        self.app_type = self.__class__.__name__.replace('Generator', '').lower()
+        self.logger = logging.getLogger(
+            f'Parrot.Generator.{self.app_type}'
+        )
+
+    @abstractmethod
+    def get_system_prompt(self) -> str:
+        """
+        Return the system prompt template for this generator.
+
+        Should include placeholders for: {user_description}, {additional_requirements},
+        {high_quality_example}
+        """
+        pass
+
+    @abstractmethod
+    def get_output_schema(self) -> Type[BaseModel]:
+        """Return the Pydantic schema for structured output."""
+        pass
+
+    @abstractmethod
+    def get_examples(self) -> str:
+        """Return high-quality example code to guide the LLM."""
+        pass
+
+    def build_prompt(
+        self,
+        user_description: str,
+        additional_requirements: str = "",
+        **kwargs
+    ) -> str:
+        """
+        Build the complete generation prompt.
+
+        Args:
+            user_description: User's description of desired app
+            additional_requirements: Extra technical requirements
+            **kwargs: Additional template variables
+
+        Returns:
+            Formatted prompt string
+        """
+        template = self.get_system_prompt()
+        examples = self.get_examples()
+
+        return template.format(
+            user_description=user_description,
+            additional_requirements=additional_requirements,
+            high_quality_example=examples,
+            **kwargs
+        )
+
+    async def generate(
+        self,
+        description: str,
+        additional_requirements: Optional[str] = None,
+        use_structured_output: bool = True,
+        save_to_file: bool = False,
+        filename: Optional[str] = None,
+        temperature: float = 0.3,
+        max_tokens: int = 4096,
+        **kwargs
+    ) -> AIMessage:
+        """
+        Generate a web application based on description.
+
+        Args:
+            description: Detailed description of the app to build
+            additional_requirements: Optional extra requirements
+            use_structured_output: Whether to use structured output schema
+            save_to_file: Whether to save generated code to file
+            filename: Custom filename (auto-generated if None)
+            temperature: LLM temperature for generation
+            max_tokens: Maximum tokens for generation
+            **kwargs: Additional arguments passed to LLM
+
+        Returns:
+            AIMessage with generated app code
+        """
+        self.logger.info(f"Generating {self.app_type} app...")
+
+        # Build the prompt
+        prompt = self.build_prompt(
+            user_description=description,
+            additional_requirements=additional_requirements or ""
+        )
+
+        # Get structured output schema
+        output_schema = self.get_output_schema() if use_structured_output else None
+
+        # Generate with LLM
+        response = await self.llm.ask(
+            prompt=prompt,
+            structured_output=output_schema,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            **kwargs
+        )
+
+        # Validate and optionally save
+        if response.output:
+            code = self._extract_code(response.output)
+            validation = self.validate_output(code)
+
+            if not validation['valid']:
+                self.logger.warning(f"Generated code has issues: {validation['errors']}")
+
+            if save_to_file:
+                filepath = self._save_to_file(response.output, filename)
+                self.logger.info(f"Saved app to: {filepath}")
+                response.metadata = response.metadata or {}
+                response.metadata['saved_path'] = str(filepath)
+
+        return response
+
+    def _extract_code(self, output: Union[BaseModel, str]) -> str:
+        """Extract code string from output."""
+        if isinstance(output, str):
+            return output
+        if hasattr(output, 'code'):
+            return output.code
+        return str(output)
+
+    def _save_to_file(self, output: BaseModel, filename: Optional[str] = None) -> Path:
+        """Save generated code to file."""
+        if self.output_dir is None:
+            raise ValueError("output_dir must be set to save files")
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        if filename is None:
+            # Auto-generate filename from title or timestamp
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            title = getattr(output, 'title', f'{self.app_type}_app')
+            title = title.lower().replace(' ', '_')
+            filename = f"{title}_{timestamp}"
+
+        # Add appropriate extension
+        extension = self._get_file_extension()
+        if not filename.endswith(extension):
+            filename += extension
+
+        filepath = self.output_dir / filename
+        filepath.write_text(output.code)
+
+        return filepath
+
+    def _get_file_extension(self) -> str:
+        """Get appropriate file extension for this app type."""
+        extensions = {
+            'streamlit': '.py',
+            'react': '.jsx',
+            'html': '.html'
+        }
+        return extensions.get(self.app_type, '.txt')
+
+    def validate_output(self, code: str) -> Dict[str, Any]:
+        """
+        Validate the generated code.
+
+        Override in subclasses for app-specific validation.
+
+        Returns:
+            Dict with 'valid', 'errors', 'warnings' keys
+        """
+        return {
+            "valid": True,
+            "errors": [],
+            "warnings": []
+        }

parrot/generators/html.py

@@ -0,0 +1,293 @@
+from typing import Type, List
+from pydantic import BaseModel, Field
+from .base import WebAppGenerator
+
+
+class HTMLApp(BaseModel):
+    """Pydantic schema for HTML application output."""
+    code: str = Field(description="Complete HTML code with embedded CSS and JS")
+    title: str = Field(description="Page title")
+    description: str = Field(description="App description")
+    features: List[str] = Field(description="Key features implemented")
+
+
+class HTMLGenerator(WebAppGenerator):
+    """Generator for standalone HTML/CSS/JS applications."""
+
+    def get_system_prompt(self) -> str:
+        return """You are an expert web developer creating modern, self-contained HTML applications.
+
+**User Requirements:**
+{user_description}
+
+**Technical Requirements:**
+- Complete HTML5 document in a single file
+- Embedded CSS using <style> tags
+- Embedded JavaScript using <script> tags
+- Vanilla JavaScript (ES6+) - no frameworks required
+- Responsive design with mobile-first approach
+- Cross-browser compatible (Chrome, Firefox, Safari, Edge)
+
+**Libraries Available via CDN (if needed):**
+- Chart.js for charts: https://cdn.jsdelivr.net/npm/chart.js
+- Tailwind CSS: https://cdn.tailwindcss.com
+- Alpine.js for reactivity: https://unpkg.com/alpinejs
+
+**HTML Structure:**
+1. <!DOCTYPE html> declaration
+2. <html lang="en"> with proper lang attribute
+3. <head> with meta tags, title, and styles
+4. <body> with semantic HTML5 elements
+5. <script> section at the end
+
+**CSS Standards:**
+- Modern CSS with flexbox/grid layouts
+- CSS custom properties for theming
+- Smooth transitions and animations
+- Mobile-responsive with media queries
+- Clean, maintainable styling
+
+**JavaScript Standards:**
+- ES6+ syntax (const, let, arrow functions)
+- Event delegation for better performance
+- Error handling with try-catch
+- Local storage for data persistence (if appropriate)
+- Form validation
+- Loading states for async operations
+
+**Design Requirements:**
+- Modern, clean aesthetic
+- Intuitive user interface
+- Loading indicators for async operations
+- Error messages for validation
+- Smooth animations and transitions
+- Accessible (ARIA labels, keyboard navigation)
+
+Generate a complete, production-ready HTML application."""
+
+    def get_output_schema(self) -> Type[BaseModel]:
+        return HTMLApp
+
+    def get_examples(self) -> str:
+        return '''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Task Manager</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        :root {
+            --primary: #3b82f6;
+            --primary-dark: #2563eb;
+            --bg: #f9fafb;
+            --card: #ffffff;
+            --text: #1f2937;
+            --text-light: #6b7280;
+            --border: #e5e7eb;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: var(--bg);
+            color: var(--text);
+            line-height: 1.6;
+        }
+
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 2rem;
+        }
+
+        .header {
+            background: var(--card);
+            padding: 2rem;
+            border-radius: 1rem;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+            margin-bottom: 2rem;
+        }
+
+        h1 {
+            font-size: 2rem;
+            margin-bottom: 0.5rem;
+        }
+
+        .input-group {
+            display: flex;
+            gap: 1rem;
+            margin-top: 1rem;
+        }
+
+        input {
+            flex: 1;
+            padding: 0.75rem;
+            border: 1px solid var(--border);
+            border-radius: 0.5rem;
+            font-size: 1rem;
+        }
+
+        button {
+            padding: 0.75rem 1.5rem;
+            background: var(--primary);
+            color: white;
+            border: none;
+            border-radius: 0.5rem;
+            font-size: 1rem;
+            cursor: pointer;
+            transition: background 0.3s;
+        }
+
+        button:hover {
+            background: var(--primary-dark);
+        }
+
+        .task-list {
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+        }
+
+        .task {
+            background: var(--card);
+            padding: 1rem;
+            border-radius: 0.5rem;
+            display: flex;
+            align-items: center;
+            gap: 1rem;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+            transition: transform 0.2s;
+        }
+
+        .task:hover {
+            transform: translateY(-2px);
+        }
+
+        .task.completed {
+            opacity: 0.6;
+            text-decoration: line-through;
+        }
+
+        @media (max-width: 640px) {
+            .container {
+                padding: 1rem;
+            }
+            .input-group {
+                flex-direction: column;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>📝 Task Manager</h1>
+            <p style="color: var(--text-light)">Manage your daily tasks efficiently</p>
+
+            <div class="input-group">
+                <input
+                    type="text"
+                    id="taskInput"
+                    placeholder="Enter a new task..."
+                    aria-label="New task input"
+                >
+                <button onclick="addTask()" aria-label="Add task">
+                    Add Task
+                </button>
+            </div>
+        </div>
+
+        <div class="task-list" id="taskList"></div>
+    </div>
+
+    <script>
+        // Load tasks from localStorage
+        let tasks = JSON.parse(localStorage.getItem('tasks') || '[]');
+
+        // Initialize on page load
+        document.addEventListener('DOMContentLoaded', () => {
+            renderTasks();
+
+            // Allow Enter key to add task
+            document.getElementById('taskInput').addEventListener('keypress', (e) => {
+                if (e.key === 'Enter') addTask();
+            });
+        });
+
+        function addTask() {
+            const input = document.getElementById('taskInput');
+            const text = input.value.trim();
+
+            if (!text) {
+                alert('Please enter a task');
+                return;
+            }
+
+            tasks.push({
+                id: Date.now(),
+                text: text,
+                completed: false,
+                createdAt: new Date().toISOString()
+            });
+
+            saveTasks();
+            renderTasks();
+            input.value = '';
+            input.focus();
+        }
+
+        function toggleTask(id) {
+            tasks = tasks.map(task =>
+                task.id === id ? {...task, completed: !task.completed} : task
+            );
+            saveTasks();
+            renderTasks();
+        }
+
+        function deleteTask(id) {
+            tasks = tasks.filter(task => task.id !== id);
+            saveTasks();
+            renderTasks();
+        }
+
+        function saveTasks() {
+            localStorage.setItem('tasks', JSON.stringify(tasks));
+        }
+
+        function renderTasks() {
+            const listEl = document.getElementById('taskList');
+
+            if (tasks.length === 0) {
+                listEl.innerHTML = '<p style="text-align:center;color:var(--text-light)">No tasks yet. Add one above!</p>';
+                return;
+            }
+
+            listEl.innerHTML = tasks.map(task => `
+                <div class="task ${task.completed ? 'completed' : ''}">
+                    <input
+                        type="checkbox"
+                        ${task.completed ? 'checked' : ''}
+                        onchange="toggleTask(${task.id})"
+                        aria-label="Toggle task completion"
+                    >
+                    <span style="flex:1">${task.text}</span>
+                    <button
+                        onclick="deleteTask(${task.id})"
+                        style="background:#ef4444;padding:0.5rem 1rem"
+                        aria-label="Delete task"
+                    >
+                        Delete
+                    </button>
+                </div>
+            `).join('');
+        }
+    </script>
+</body>
+</html>
+'''