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

parrot/generators/react.py

@@ -0,0 +1,205 @@
+from typing import Type, List
+from pydantic import BaseModel, Field
+from .base import WebAppGenerator
+
+
+class ReactApp(BaseModel):
+    """Pydantic schema for React application output."""
+    code: str = Field(description="Complete React component code")
+    component_name: str = Field(description="Main component name")
+    description: str = Field(description="App description")
+    dependencies: List[str] = Field(
+        description="External dependencies used",
+        default_factory=lambda: ["react", "recharts", "lucide-react"]
+    )
+    features: List[str] = Field(description="Key features implemented")
+
+
+class ReactGenerator(WebAppGenerator):
+    """Generator for React applications."""
+
+    def get_system_prompt(self) -> str:
+        return """You are a senior React developer building modern, responsive web applications.
+
+**User Requirements:**
+{user_description}
+
+**Technical Stack:**
+- React 18+ with Hooks (useState, useEffect, useReducer, useMemo, useCallback)
+- Tailwind CSS for ALL styling (no inline styles)
+- Recharts for charts and data visualization
+- Lucide React for icons
+- Mock data only (no external API calls)
+
+**Code Quality Standards:**
+- Functional components only (no class components)
+- Proper prop destructuring and validation
+- Clean, modular component structure
+- Responsive design using Tailwind's responsive classes
+- Accessibility: ARIA labels, semantic HTML, keyboard navigation
+- Performance: useMemo for expensive computations, useCallback for event handlers
+
+**Styling Requirements:**
+- Use ONLY Tailwind utility classes
+- Consistent color palette (blue-600 primary, gray-50 backgrounds)
+- Proper spacing scale (p-4, p-6, etc.)
+- Smooth transitions (transition-all duration-300)
+- Hover states for interactive elements
+- Mobile-first responsive design
+
+**Component Structure:**
+1. Import statements at top
+2. Component definition with clear function name
+3. State declarations grouped together
+4. Helper functions
+5. useEffect hooks
+6. JSX return statement
+7. Default export
+
+**Best Practices:**
+- Break large components into smaller ones
+- Keep components under 200 lines
+- Use meaningful variable names
+- Add comments for complex logic
+- Include loading and error states
+- Implement proper form validation
+
+**Example Quality Standard:**
+{high_quality_example}
+
+Generate a complete, self-contained React component as a default export."""
+
+    def get_output_schema(self) -> Type[BaseModel]:
+        return ReactApp
+
+    def get_examples(self) -> str:
+        return '''
+import React, { useState, useMemo } from 'react';
+import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer } from 'recharts';
+import { TrendingUp, Download, Filter } from 'lucide-react';
+
+const Dashboard = () => {
+  // Mock data
+  const [data] = useState([
+    { name: 'Jan', revenue: 4000, expenses: 2400 },
+    { name: 'Feb', revenue: 3000, expenses: 1398 },
+    { name: 'Mar', revenue: 2000, expenses: 9800 },
+    { name: 'Apr', revenue: 2780, expenses: 3908 },
+    { name: 'May', revenue: 1890, expenses: 4800 },
+    { name: 'Jun', revenue: 2390, expenses: 3800 }
+  ]);
+
+  const [filterActive, setFilterActive] = useState(false);
+
+  // Compute metrics
+  const metrics = useMemo(() => ({
+    totalRevenue: data.reduce((sum, item) => sum + item.revenue, 0),
+    totalExpenses: data.reduce((sum, item) => sum + item.expenses, 0),
+    avgRevenue: data.reduce((sum, item) => sum + item.revenue, 0) / data.length
+  }), [data]);
+
+  const handleExport = () => {
+    const csv = [
+      'Month,Revenue,Expenses',
+      ...data.map(d => `${d.name},${d.revenue},${d.expenses}`)
+    ].join('\\n');
+
+    const blob = new Blob([csv], { type: 'text/csv' });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'data.csv';
+    a.click();
+  };
+
+  return (
+    <div className="min-h-screen bg-gray-50 p-6">
+      <div className="max-w-7xl mx-auto">
+        {/* Header */}
+        <div className="bg-white rounded-lg shadow-lg p-6 mb-6">
+          <div className="flex items-center justify-between mb-4">
+            <div className="flex items-center gap-3">
+              <TrendingUp className="text-blue-600" size={32} />
+              <div>
+                <h1 className="text-3xl font-bold text-gray-900">
+                  Financial Dashboard
+                </h1>
+                <p className="text-gray-600">Track your revenue and expenses</p>
+              </div>
+            </div>
+
+            <div className="flex gap-2">
+              <button
+                onClick={() => setFilterActive(!filterActive)}
+                className="flex items-center gap-2 px-4 py-2 bg-gray-100 hover:bg-gray-200 rounded-lg transition-colors"
+                aria-label="Toggle filters"
+              >
+                <Filter size={18} />
+                Filters
+              </button>
+              <button
+                onClick={handleExport}
+                className="flex items-center gap-2 px-4 py-2 bg-blue-600 text-white hover:bg-blue-700 rounded-lg transition-colors"
+                aria-label="Export data"
+              >
+                <Download size={18} />
+                Export
+              </button>
+            </div>
+          </div>
+
+          {/* Metrics */}
+          <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+            <div className="bg-gradient-to-br from-blue-50 to-blue-100 rounded-lg p-4">
+              <div className="text-sm text-blue-600 font-medium mb-1">
+                Total Revenue
+              </div>
+              <div className="text-2xl font-bold text-blue-900">
+                ${metrics.totalRevenue.toLocaleString()}
+              </div>
+            </div>
+            <div className="bg-gradient-to-br from-red-50 to-red-100 rounded-lg p-4">
+              <div className="text-sm text-red-600 font-medium mb-1">
+                Total Expenses
+              </div>
+              <div className="text-2xl font-bold text-red-900">
+                ${metrics.totalExpenses.toLocaleString()}
+              </div>
+            </div>
+            <div className="bg-gradient-to-br from-green-50 to-green-100 rounded-lg p-4">
+              <div className="text-sm text-green-600 font-medium mb-1">
+                Avg Revenue
+              </div>
+              <div className="text-2xl font-bold text-green-900">
+                ${Math.round(metrics.avgRevenue).toLocaleString()}
+              </div>
+            </div>
+          </div>
+        </div>
+
+        {/* Chart */}
+        <div className="bg-white rounded-lg shadow-lg p-6">
+          <h2 className="text-xl font-bold text-gray-900 mb-4">
+            Monthly Comparison
+          </h2>
+          <ResponsiveContainer width="100%" height={400}>
+            <BarChart data={data}>
+              <CartesianGrid strokeDasharray="3 3" />
+              <XAxis dataKey="name" />
+              <YAxis />
+              <Tooltip />
+              <Bar dataKey="revenue" fill="#3b82f6" name="Revenue" />
+              <Bar dataKey="expenses" fill="#ef4444" name="Expenses" />
+            </BarChart>
+          </ResponsiveContainer>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default Dashboard;
+'''
+
+    def _get_file_extension(self) -> str:
+        return '.jsx'

parrot/generators/streamlit.py

@@ -0,0 +1,203 @@
+from typing import Type, List
+import ast
+from pydantic import BaseModel, Field
+from .base import WebAppGenerator
+
+
+class StreamlitApp(BaseModel):
+    """Pydantic schema for Streamlit application output."""
+    code: str = Field(description="Complete Streamlit Python code")
+    title: str = Field(description="App title")
+    description: str = Field(description="Brief description of the app")
+    requirements: List[str] = Field(
+        description="Python package requirements",
+        default_factory=lambda: ["streamlit"]
+    )
+    features: List[str] = Field(description="List of main features")
+
+
+class StreamlitGenerator(WebAppGenerator):
+    """Generator for Streamlit applications."""
+
+    def get_system_prompt(self) -> str:
+        return """You are an expert Streamlit developer creating production-ready applications.
+
+**User Requirements:**
+{user_description}
+
+{additional_requirements}
+
+**Technical Specifications:**
+- Streamlit version: 1.28+
+- Python 3.10+
+- Use st.cache_data for expensive computations
+- Implement proper error handling with try-except blocks
+- Add loading states with st.spinner()
+- Use st.session_state for state management
+- Add input validation and clear error messages
+
+**Design Guidelines:**
+- Clean, modern UI with st.columns for layout
+- Consistent spacing with st.divider() and padding
+- Helpful tooltips using help parameter
+- Clear section headers with st.header() and st.subheader()
+- Data export functionality where appropriate
+- Mobile-responsive considerations
+
+**Code Structure:**
+1. Required imports at the top
+2. Page configuration using st.set_page_config() with appropriate title and layout
+3. Helper functions decorated with @st.cache_data where appropriate
+4. Main application logic
+5. if __name__ == "__main__": block at the end
+
+**Quality Standards:**
+- All functions must have docstrings
+- Use type hints for function parameters
+- Include comments for complex logic
+- Handle edge cases and errors gracefully
+- Use st.empty() for dynamic content updates
+- Add st.success(), st.warning(), st.error() for user feedback
+
+**Example of Expected Quality:**
+{high_quality_example}
+
+Generate a complete, production-ready Streamlit application now."""
+
+    def get_output_schema(self) -> Type[BaseModel]:
+        return StreamlitApp
+
+    def get_examples(self) -> str:
+        return '''
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from datetime import datetime
+
+# Page configuration
+st.set_page_config(
+    page_title="Data Analysis Dashboard",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Cache expensive operations
+@st.cache_data
+def load_data() -> pd.DataFrame:
+    """Load and prepare sample data."""
+    return pd.DataFrame({
+        'date': pd.date_range('2024-01-01', periods=100),
+        'category': ['A', 'B', 'C', 'D'] * 25,
+        'value': np.random.randint(10, 100, 100)
+    })
+
+@st.cache_data
+def calculate_metrics(df: pd.DataFrame) -> dict:
+    """Calculate summary metrics."""
+    return {
+        'total': df['value'].sum(),
+        'average': df['value'].mean(),
+        'max': df['value'].max(),
+        'min': df['value'].min()
+    }
+
+def main():
+    """Main application function."""
+    st.title("📊 Data Analysis Dashboard")
+    st.markdown("Analyze your data with interactive visualizations")
+
+    # Sidebar controls
+    with st.sidebar:
+        st.header("Filters")
+        categories = st.multiselect(
+            "Select Categories",
+            options=['A', 'B', 'C', 'D'],
+            default=['A', 'B'],
+            help="Choose which categories to display"
+        )
+
+    # Load data
+    try:
+        with st.spinner("Loading data..."):
+            df = load_data()
+
+        # Filter data
+        filtered_df = df[df['category'].isin(categories)]
+
+        if filtered_df.empty:
+            st.warning("No data available for selected filters")
+            return
+
+        # Metrics row
+        metrics = calculate_metrics(filtered_df)
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            st.metric("Total", f"{metrics['total']:,.0f}")
+        with col2:
+            st.metric("Average", f"{metrics['average']:.1f}")
+        with col3:
+            st.metric("Maximum", metrics['max'])
+        with col4:
+            st.metric("Minimum", metrics['min'])
+
+        st.divider()
+
+        # Visualization
+        st.subheader("Trend Analysis")
+        fig = px.line(
+            filtered_df,
+            x='date',
+            y='value',
+            color='category',
+            title='Values Over Time'
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Data table
+        with st.expander("View Raw Data"):
+            st.dataframe(filtered_df, use_container_width=True)
+
+            # Export functionality
+            csv = filtered_df.to_csv(index=False)
+            st.download_button(
+                label="Download CSV",
+                data=csv,
+                file_name=f"data_export_{datetime.now():%Y%m%d}.csv",
+                mime="text/csv"
+            )
+
+        st.success("✓ Analysis complete!")
+
+    except Exception as e:
+        st.error(f"An error occurred: {str(e)}")
+        st.exception(e)
+
+if __name__ == "__main__":
+    main()
+'''
+
+    def validate_output(self, code: str) -> dict:
+        """Validate Python syntax of generated Streamlit code."""
+        errors = []
+        warnings = []
+
+        try:
+            ast.parse(code)
+        except SyntaxError as e:
+            errors.append(f"Syntax error: {e}")
+
+        # Check for required Streamlit imports
+        if 'import streamlit' not in code:
+            warnings.append("Missing streamlit import")
+
+        # Check for page config
+        if 'st.set_page_config' not in code:
+            warnings.append("Missing st.set_page_config() - recommended for better UX")
+
+        return {
+            "valid": len(errors) == 0,
+            "errors": errors,
+            "warnings": warnings
+        }

parrot/generators/template.py

@@ -0,0 +1,105 @@
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from pydantic import BaseModel
+import json
+from datamodel.parsers.json import json_encoder, json_decoder  # pylint: disable=E0611 # noqa
+
+
+class AppTemplate(BaseModel):
+    """Template for app generation."""
+    name: str
+    description: str
+    app_type: str  # streamlit, react, html
+    base_structure: Dict[str, Any]
+    required_features: List[str]
+    optional_features: List[str]
+    styling_theme: Dict[str, str]
+
+
+class TemplateManager:
+    """
+    Manages reusable templates for web app generation.
+    """
+
+    def __init__(self, templates_dir: Path):
+        self.templates_dir = templates_dir
+        self.templates_dir.mkdir(parents=True, exist_ok=True)
+        self._templates: Dict[str, AppTemplate] = {}
+        self._load_templates()
+
+    def _load_templates(self):
+        """Load templates from directory."""
+        for template_file in self.templates_dir.glob("*.json"):
+            with open(template_file) as f:
+                data = json_decoder(f)
+                template = AppTemplate(**data)
+                self._templates[template.name] = template
+
+    def create_template(
+        self,
+        name: str,
+        app_type: str,
+        description: str,
+        base_structure: Dict[str, Any],
+        required_features: List[str],
+        optional_features: List[str] = None,
+        styling_theme: Dict[str, str] = None
+    ) -> AppTemplate:
+        """Create a new template."""
+        template = AppTemplate(
+            name=name,
+            description=description,
+            app_type=app_type,
+            base_structure=base_structure,
+            required_features=required_features,
+            optional_features=optional_features or [],
+            styling_theme=styling_theme or {}
+        )
+
+        # Save to file
+        template_file = self.templates_dir / f"{name}.json"
+        with open(template_file, 'w') as f:
+            json_encoder(template.model_dump(), f)
+
+        self._templates[name] = template
+        return template
+
+    def get_template(self, name: str) -> Optional[AppTemplate]:
+        """Get a template by name."""
+        return self._templates.get(name)
+
+    def list_templates(self) -> List[str]:
+        """List all available templates."""
+        return list(self._templates.keys())
+
+    def generate_from_template(
+        self,
+        template_name: str,
+        customization: Dict[str, Any],
+        llm_client
+    ) -> str:
+        """Generate an app from a template with customization."""
+        template = self.get_template(template_name)
+        if not template:
+            raise ValueError(f"Template '{template_name}' not found")
+
+        prompt = f"""Generate a {template.app_type} application based on this template:
+
+**Template:** {template.name}
+{template.description}
+
+**Required Features:**
+{chr(10).join(f'- {f}' for f in template.required_features)}
+
+**Customizations:**
+{chr(10).join(f'- {k}: {v}' for k, v in customization.items())}
+
+**Base Structure:**
+{json.dumps(template.base_structure, indent=2)}
+
+**Styling Theme:**
+{json.dumps(template.styling_theme, indent=2)}
+
+Generate complete code following the template structure with the specified customizations."""
+
+        return prompt

parrot/handlers/__init__.py

@@ -0,0 +1,4 @@
+"""
+Parrot basic Handlers.
+"""
+from .bots import ChatbotHandler