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

parrot/outputs/formats/table.py

@@ -0,0 +1,397 @@
+from typing import Any, Optional, Tuple, List, Dict, Union
+import json
+import pandas as pd
+from .base import BaseRenderer
+from . import register_renderer
+from ...models.outputs import OutputMode
+
+try:
+    from rich.table import Table as RichTable
+    from rich.console import Console
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+try:
+    from ipywidgets import HTML as IPyHTML
+    IPYWIDGETS_AVAILABLE = True
+except ImportError:
+    IPYWIDGETS_AVAILABLE = False
+
+
+GRIDJS_SYSTEM_PROMPT = """
+**GRID.JS CODE GENERATION MODE**
+
+**Objective:** Generate a single, valid Grid.js Javascript code block.
+
+**INSTRUCTIONS:**
+1.  **Analyze Request:** Understand the user's goal for the table.
+2.  **Generate Grid.js Code:** Create a complete Grid.js or ag-grid configuration.
+3.  **Use Sample Data:** If the user asks for a type of table but doesn't provide data, generate appropriate sample data to illustrate the table's structure.
+4.  **Output:** Return ONLY the Javascript code inside a ```javascript code block. Do not add explanations.
+
+**BASIC STRUCTURE EXAMPLE:**
+
+* If the user requests a gridjs table, respond with code similar to the following:
+```javascript
+new gridjs.Grid({
+  columns: ["Name", "Email", "Phone Number"],
+  data: [
+    ["John", "john@example.com", "(353) 01 222 3333"],
+    ["Mark", "mark@gmail.com", "(01) 22 888 4444"],
+    ["Eoin", "eoin@gmail.com", "0097 22 654 00033"],
+    ["Sarah", "sarahcdd@gmail.com", "+322 876 1233"],
+    ["Afshin", "afshin@mail.com", "(353) 22 87 8356"]
+  ]
+}).render(document.getElementById("wrapper"));
+```
+
+* if the user requests a ag-grid table, respond with code similar to the following:
+```javascript
+const columnDefs = [
+    { headerName: "Make", field: "make" },
+    { headerName: "Model", field: "model" },
+    { headerName: "Price", field: "price" }
+];
+const rowData = [
+    { make: "Toyota", model: "Celica", price: 35000 },
+    { make: "Ford", model: "Mondeo", price: 32000 },
+    { make: "Porsche", model: "Boxster", price: 72000 }
+];
+const gridOptions = {
+    columnDefs: columnDefs,
+    rowData: rowData
+};
+new agGrid.Grid(document.getElementById('myGrid'), gridOptions);
+```
+"""
+
+@register_renderer(OutputMode.TABLE, system_prompt=GRIDJS_SYSTEM_PROMPT)
+class TableRenderer(BaseRenderer):
+    """
+    Renderer for Tables supporting Rich (Terminal), HTML (Simple), Grid.js, and Ag-Grid.
+    """
+
+    def _extract_data(self, response: Any) -> pd.DataFrame:
+        """Extract data into a Pandas DataFrame."""
+        # 1. Handle PandasAgentResponse
+        output = getattr(response, 'output', None)
+
+        if output is not None:
+            if hasattr(output, 'to_dataframe'):
+                return output.to_dataframe()
+            if hasattr(output, 'data') and output.data is not None:
+                return pd.DataFrame(output.data)
+
+        # 2. Handle direct DataFrame
+        if isinstance(output, pd.DataFrame):
+            return output
+
+        # 3. Handle list of dicts
+        if isinstance(output, list):
+            return pd.DataFrame(output)
+
+        # 4. Handle dict (single record or dict of lists)
+        if isinstance(output, dict):
+            return pd.DataFrame(output) if all(isinstance(v, list) for v in output.values()) else pd.DataFrame([output])
+
+        # 5. Fallback: Check response.data attribute directly (AIMessage)
+        if hasattr(response, 'data') and response.data is not None:
+            if isinstance(response.data, pd.DataFrame):
+                return response.data
+            return pd.DataFrame(response.data)
+
+        return pd.DataFrame()
+
+    def _render_rich_table(self, df: pd.DataFrame, title: str) -> Any:
+        """Render a Rich Table object."""
+        if not RICH_AVAILABLE:
+            return df.to_string()
+
+        table = RichTable(title=title, show_header=True, header_style="bold magenta")
+
+        # Add columns
+        for column in df.columns:
+            table.add_column(str(column), overflow="fold")
+
+        # Add rows
+        for _, row in df.iterrows():
+            table.add_row(*[str(item) for item in row])
+
+        return table
+
+    def _render_simple_table(self, data: Any) -> str:
+        if isinstance(data, pd.DataFrame):
+            return data.to_html(index=False)
+        elif isinstance(data, list) and all(isinstance(i, dict) for i in data):
+            df = pd.DataFrame(data)
+            return df.to_html(index=False)
+        elif isinstance(data, str):
+            return data
+        else:
+            raise TypeError(f"Unsupported data type for simple table: {type(data)}")
+
+    def _generate_gridjs_code(self, df: pd.DataFrame, element_id: str = "wrapper") -> str:
+        """Generate Grid.js configuration and render code."""
+        columns = df.columns.tolist()
+        # Convert data to JSON-serializable list of lists
+        data = df.values.tolist()
+
+        # Serialize safely to avoid JS syntax errors
+        json_data = json.dumps(data)
+        json_columns = json.dumps(columns)
+
+        return f"""
+            new gridjs.Grid({{
+                columns: {json_columns},
+                data: {json_data},
+                search: true,
+                sort: true,
+                pagination: {{
+                    limit: 10
+                }},
+                className: {{
+                    table: 'table-body'
+                }}
+            }}).render(document.getElementById("{element_id}"));
+        """
+
+    def _generate_aggrid_code(self, df: pd.DataFrame, element_id: str = "wrapper") -> str:
+        """Generate Ag-Grid configuration and render code."""
+        # Define columns definition
+        column_defs = [
+            {"headerName": col, "field": col, "sortable": True, "filter": True} for col in df.columns
+        ]
+
+        # Data is list of dicts for Ag-Grid
+        row_data = df.to_dict(orient='records')
+
+        json_col_defs = json.dumps(column_defs)
+        json_row_data = json.dumps(row_data)
+
+        return f"""
+const gridOptions = {{
+    columnDefs: {json_col_defs},
+    rowData: {json_row_data},
+    pagination: true,
+    paginationPageSize: 10,
+    defaultColDef: {{
+        flex: 1,
+        minWidth: 100,
+        resizable: true,
+    }}
+}};
+const gridDiv = document.getElementById("{element_id}");
+agGrid.createGrid(gridDiv, gridOptions);
+        """
+
+    def _build_html_document(
+        self,
+        table_content: str,
+        table_mode: str,
+        title: str = "Table",
+        html_mode: str = "partial",
+        element_id: str = "wrapper",
+        script_nonce: Optional[str] = None,
+        style_nonce: Optional[str] = None,
+        content_security_policy: Optional[str] = None,
+    ) -> str:
+        """
+        Build the final HTML output (partial or complete).
+
+        Args:
+            table_content: The HTML table or JS code.
+            table_mode: 'simple', 'grid', or 'ag-grid'.
+            html_mode: 'partial' (embeddable) or 'complete' (standalone).
+        """
+        head_content = ""
+        partial_head_content = ""
+        body_content = ""
+        script_nonce_attr = f' nonce="{script_nonce}"' if script_nonce else ""
+        style_nonce_attr = f' nonce="{style_nonce}"' if style_nonce else ""
+
+        # 1. Configuration based on mode
+        if table_mode == 'grid':
+            # Grid.js CDNs
+            head_content = f"""
+                <link href="https://unpkg.com/gridjs/dist/theme/mermaid.min.css" rel="stylesheet" />
+                <script src="https://unpkg.com/gridjs/dist/gridjs.umd.js" defer></script>
+            """
+            partial_head_content = head_content
+            body_content = f"""
+                <div id="{element_id}"></div>
+                <script{script_nonce_attr}>
+                    document.addEventListener('DOMContentLoaded', function () {{
+                        {table_content}
+                    }});
+                </script>
+            """
+
+        elif table_mode == 'ag-grid':
+            # Ag-Grid CDNs
+            head_content = """
+                <script src="https://cdn.jsdelivr.net/npm/ag-grid-community/dist/ag-grid-community.min.js" defer></script>
+            """
+            partial_head_content = head_content
+            # Note: Ag-Grid requires a height on the container
+            body_content = f"""
+                <div id="{element_id}" class="ag-theme-alpine" style="height: 500px; width: 100%;"></div>
+                <script{script_nonce_attr}>
+                    document.addEventListener('DOMContentLoaded', function () {{
+                        if (window.agGrid && document.getElementById('{element_id}')) {{
+                            {table_content}
+                        }}
+                    }});
+                </script>
+            """
+
+        else:
+            # simple
+            # Basic Bootstrap for simple tables
+            head_content = f"""
+                <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
+                <style{style_nonce_attr}>
+                    .dataframe {{ width: 100%; }}
+                    .dataframe td, .dataframe th {{ padding: 8px; text-align: left; border-bottom: 1px solid #ddd; }}
+                </style>
+            """
+            partial_head_content = f"""
+                <style{style_nonce_attr}>
+                    @import url('https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css');
+                    .dataframe {{ width: 100%; }}
+                    .dataframe td, .dataframe th {{ padding: 8px; text-align: left; border-bottom: 1px solid #ddd; }}
+                </style>
+            """
+            body_content = f'<div class="table-responsive">{table_content}</div>'
+
+        # Optional CSP meta for complete documents. This is useful when a nonce is provided
+        # so that inline scripts/styles still satisfy strict policies.
+        csp_meta_tag = ""
+        if html_mode == "complete":
+            if content_security_policy:
+                csp_meta_tag = f"<meta http-equiv=\"Content-Security-Policy\" content=\"{content_security_policy}\">"
+            elif script_nonce or style_nonce:
+                csp_parts = [
+                    "default-src 'self' https://cdn.jsdelivr.net https://unpkg.com",
+                    "img-src 'self' data: https://cdn.jsdelivr.net https://unpkg.com",
+                    "font-src 'self' data: https://cdn.jsdelivr.net https://unpkg.com",
+                ]
+                script_src = ["'self'", "https://cdn.jsdelivr.net", "https://unpkg.com"]
+                style_src = ["'self'", "https://cdn.jsdelivr.net", "https://unpkg.com"]
+
+                if script_nonce:
+                    script_src.append(f"'nonce-{script_nonce}'")
+                else:
+                    script_src.append("'unsafe-inline'")
+
+                if style_nonce:
+                    style_src.append(f"'nonce-{style_nonce}'")
+                else:
+                    style_src.append("'unsafe-inline'")
+
+                csp_parts.append(f"script-src {' '.join(script_src)}")
+                csp_parts.append(f"style-src {' '.join(style_src)}")
+                csp_meta_tag = f"<meta http-equiv=\"Content-Security-Policy\" content=\"{' ; '.join(csp_parts)}\">"
+
+        # 2. Return Partial (Embeddable)
+        if html_mode == "partial":
+            return f"""
+            <div>
+                {partial_head_content}
+                {body_content}
+            </div>
+            """
+
+        # 3. Return Complete (Standalone)
+        return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    {csp_meta_tag}
+    <title>{title}</title>
+    {head_content}
+</head>
+<body>
+    <div class="container mt-4">
+        <h2>{title}</h2>
+        {body_content}
+    </div>
+</body>
+</html>"""
+
+    async def render(
+        self,
+        response: Any,
+        table_mode: str = 'simple', # simple, grid, ag-grid
+        title: str = 'Table',
+        environment: str = 'terminal',
+        html_mode: str = 'partial',
+        **kwargs,
+    ) -> Tuple[Any, Optional[Any]]:
+        """
+        Render table in the appropriate format.
+
+        Returns:
+            Tuple[Any, Optional[Any]]: (raw_data_df, rendered_output)
+        """
+        # 1. Extract Data
+        df = self._extract_data(response)
+
+        if df.empty:
+            return "No Data Available", None
+
+        data_content = df.to_dict(orient='records')
+
+        output_format = kwargs.get('output_format', environment)
+
+        # 2. Environment: Terminal -> Rich Table
+        if output_format == 'terminal':
+            rich_table = self._render_rich_table(df, title)
+            return data_content, rich_table
+
+        # 3. Prepare Content for HTML/JS
+        content = ""
+        if table_mode == 'simple':
+            # Convert to HTML Table
+            content = df.to_html(classes="table table-striped table-bordered", index=False)
+
+        elif table_mode == 'grid':
+            # Generate Grid.js Code
+            # Check if code was pre-generated by LLM (in response.code) - Future proofing
+            if hasattr(response, 'code') and isinstance(response.code, str) and "new gridjs.Grid" in response.code:
+                content = response.code
+            else:
+                content = self._generate_gridjs_code(df, "wrapper_grid")
+
+        elif table_mode == 'ag-grid':
+            # Generate Ag-Grid Code
+            if hasattr(response, 'code') and isinstance(response.code, str) and "new agGrid.Grid" in response.code:
+                content = response.code
+            else:
+                content = self._generate_aggrid_code(df, "wrapper_ag")
+
+        # 4. Build Wrapped HTML
+        wrapper_id = f"wrapper_{table_mode}" if table_mode != 'simple' else "wrapper"
+        script_nonce = kwargs.get('script_nonce')
+        style_nonce = kwargs.get('style_nonce')
+        content_security_policy = kwargs.get('content_security_policy')
+        wrapped_html = self._build_html_document(
+            content,
+            table_mode,
+            title=title,
+            html_mode=html_mode,
+            element_id=wrapper_id,
+            script_nonce=script_nonce,
+            style_nonce=style_nonce,
+            content_security_policy=content_security_policy,
+        )
+
+        # 5. Environment: Jupyter -> Widget
+        if output_format in {'jupyter', 'notebook', 'colab'}:
+            if IPYWIDGETS_AVAILABLE:
+                return df, IPyHTML(value=wrapped_html)
+            return df, wrapped_html
+
+        # 6. Environment: HTML (return string)
+        return data_content, wrapped_html

parrot/outputs/formats/template_report.py

@@ -0,0 +1,138 @@
+from typing import Any, Dict, Optional
+from dataclasses import asdict
+from ...models.outputs import OutputMode
+from ...template.engine import TemplateEngine
+from . import register_renderer
+from .base import BaseRenderer
+
+
+@register_renderer(OutputMode.TEMPLATE_REPORT)
+class TemplateReportRenderer(BaseRenderer):
+    """
+    Renders AI output using Jinja2 templates via the TemplateEngine.
+
+    Supports both file-based templates and in-memory templates via add_template().
+    """
+
+    def __init__(self, template_engine: Optional[TemplateEngine] = None):
+        """
+        Initialize the TemplateReportRenderer.
+
+        Args:
+            template_engine: Optional TemplateEngine instance. If not provided,
+            one will be created on first use.
+        """
+        self._template_engine = template_engine
+
+    @property
+    def template_engine(self) -> TemplateEngine:
+        """
+        Lazy initialization of TemplateEngine if not provided.
+
+        Returns:
+            TemplateEngine instance
+        """
+        if self._template_engine is None:
+            # Initialize with no template directories (will use in-memory only)
+            self._template_engine = TemplateEngine()
+        return self._template_engine
+
+    def add_template(self, name: str, content: str) -> None:
+        """
+        Add an in-memory template to the engine.
+
+        Args:
+            name: Template name (e.g., 'report.html', 'summary.md')
+            content: Jinja2 template content
+
+        Example:
+            renderer.add_template('report.html', '<h1>{{ title }}</h1>')
+        """
+        self.template_engine.add_templates({name: content})
+
+    async def render(self, data: Any, **kwargs: Any) -> str:
+        """
+        Renders data using a Jinja2 template asynchronously.
+
+        Args:
+            data: The data to render. Can be:
+                - dict: passed directly to template
+                - Pydantic model: converted via model_dump()
+                - dataclass: converted via asdict()
+                - any object with attributes: accessible in template
+            **kwargs: Additional arguments:
+                - template: (required) Template name to use
+                - template_engine: (optional) Override the default engine
+                - Additional kwargs are passed to the template context
+
+        Returns:
+            Rendered template content as string
+
+        Raises:
+            ValueError: If template is not provided or not found
+
+        Example:
+            result = await renderer.render(
+                {"title": "Report", "items": [1, 2, 3]},
+                template="report.html"
+            )
+        """
+        # Get template name
+        template_name: str = kwargs.pop("template", None)
+        if not template_name:
+            raise ValueError(
+                "Template name must be provided via 'template' kwarg. "
+                "Example: renderer.render(data, template='report.html')"
+            )
+
+        # Allow overriding the template engine
+        engine = kwargs.pop("template_engine", None) or self.template_engine
+
+        # Prepare the template context
+        context = self._prepare_template_context(data, kwargs)
+
+        # Render the template
+        try:
+            return await engine.render(template_name, context)
+        except FileNotFoundError as e:
+            raise ValueError(
+                f"Template '{template_name}' not found. "
+                f"Use add_template() to add in-memory templates or "
+                f"ensure the template exists in the template directories."
+            ) from e
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to render template '{template_name}': {e}"
+            ) from e
+
+    def _prepare_template_context(
+        self, data: Any, extra_kwargs: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Prepare the context dictionary for template rendering.
+
+        Args:
+            data: The main data to render
+            extra_kwargs: Additional kwargs to include in context
+
+        Returns:
+            Dictionary to pass to template
+        """
+        # Start with extra kwargs
+        context = dict(extra_kwargs)
+
+        # Handle different data types
+        if isinstance(data, dict):
+            # Merge dict data with kwargs (data takes precedence)
+            context |= data
+        elif hasattr(data, 'model_dump'):
+            # Pydantic model
+            context |= data.model_dump()
+        elif hasattr(data, '__dataclass_fields__'):
+            # Dataclass
+            context |= asdict(data)
+        else:
+            # Primitive or unknown type - wrap as 'data'
+            context['data'] = data
+
+        return context

parrot/outputs/formats/yaml.py

@@ -0,0 +1,125 @@
+from typing import Any, Tuple
+import json
+from dataclasses import is_dataclass, asdict
+from pydantic import BaseModel
+try:
+    import yaml_rs  # pylint: disable=E0401  # noqa
+    YAML_RS_AVAILABLE = True
+except ImportError:
+    YAML_RS_AVAILABLE = False
+import pandas as pd
+from datamodel.parsers.json import json_encoder  # pylint: disable=E0611  # noqa
+from . import register_renderer
+from .base import BaseRenderer
+from ...models.outputs import OutputMode
+
+
+@register_renderer(OutputMode.YAML)
+class YAMLRenderer(BaseRenderer):
+    """Renderer for YAML output using yaml-rs (Rust) or PyYAML fallback"""
+
+    def _json_as_yaml(self, data: Any, indent: int = 2) -> str:
+        """
+        Fallback: Format JSON as YAML-like structure.
+        Useful when yaml_rs is missing or fails on specific types.
+        """
+        try:
+            # First ensure it's serializable via json_encoder logic
+            if not isinstance(data, str):
+                data = json.loads(json_encoder(data))
+
+            import yaml
+            return yaml.dump(data, indent=indent, sort_keys=False, default_flow_style=False)
+        except ImportError:
+            # Manual JSON-to-YAML-ish conversion if PyYAML is also missing
+            json_str = json.dumps(data, indent=indent, sort_keys=False)
+            yaml_like = json_str.replace('{', '').replace('}', '')
+            yaml_like = yaml_like.replace('[', '').replace(']', '')
+            yaml_like = yaml_like.replace('",', '"')
+            return yaml_like.replace('"', '')
+
+    def _serialize(self, data: Any, indent: int = 2, sort_keys: bool = False) -> str:
+        """Serialize data to YAML string."""
+        try:
+            if isinstance(data, pd.DataFrame):
+                data = data.to_dict(orient='records')
+            elif is_dataclass(data):
+                data = asdict(data)
+            elif isinstance(data, BaseModel):
+                data = data.model_dump()
+            if not YAML_RS_AVAILABLE:
+                return self._json_as_yaml(data, indent)
+            try:
+                return yaml_rs.dumps(data, indent=indent, sort_keys=sort_keys)
+            except Exception:
+                # Fallback to python implementation on error
+                return self._json_as_yaml(data, indent)
+        except Exception as e:
+            print('DATA > ', data)
+            return f"error_serializing_to_yaml: {str(e)}"
+
+    def _wrap_output(self, yaml_string: str, environment: str) -> Any:
+        """
+        Wrap the YAML string into an environment-specific container.
+        """
+        # --- Terminal (Rich) ---
+        if environment == 'terminal':
+            try:
+                from rich.panel import Panel as RichPanel
+                from rich.syntax import Syntax
+
+                syntax = Syntax(yaml_string, "yaml", theme="monokai", line_numbers=True)
+                return RichPanel(syntax, title="YAML Output", border_style="green")
+            except ImportError:
+                return yaml_string
+
+        # --- Jupyter / Notebook ---
+        elif environment in {'jupyter', 'notebook'}:
+            try:
+                from ipywidgets import HTML
+                from pygments import highlight
+                from pygments.lexers import YamlLexer
+                from pygments.formatters import HtmlFormatter
+
+                formatter = HtmlFormatter(style='colorful', noclasses=True)
+                highlighted_html = highlight(yaml_string, YamlLexer(), formatter)
+
+                return HTML(
+                    value=f'<div style="max-height: 500px; overflow-y: auto; background-color: #f8f8f8; padding: 10px;">{highlighted_html}</div>'
+                )
+            except ImportError:
+                return self._wrap_html(yaml_string)
+
+        # --- HTML ---
+        elif environment == 'html':
+            return self._wrap_html(yaml_string)
+
+        # Default
+        return yaml_string
+
+    async def render(
+        self,
+        response: Any,
+        environment: str = 'default',
+        **kwargs,
+    ) -> Tuple[str, Any]:
+        """
+        Render response as YAML.
+
+        Returns:
+            Tuple[str, Any]: (yaml_string, wrapped_content)
+        """
+        indent = kwargs.get('indent', 2)
+        sort_keys = kwargs.get('sort_keys', False)
+        output_format = kwargs.get('output_format', environment)
+
+        # 1. Extract Data
+        data = self._extract_data(response)
+
+        # 2. Serialize to content string
+        yaml_string = self._serialize(data, indent=indent, sort_keys=sort_keys)
+
+        # 3. Wrap content based on environment
+        wrapped_output = self._wrap_output(yaml_string, output_format)
+
+        return yaml_string, wrapped_output