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

parrot/outputs/formats/holoviews.py

@@ -0,0 +1,310 @@
+from typing import Any, Optional, Tuple, Dict, List
+import uuid
+from pathlib import Path
+import json
+from .chart import BaseChart
+from . import register_renderer
+from ...models.outputs import OutputMode
+
+try:
+    import holoviews as hv
+    from bokeh.embed import components
+    from bokeh.resources import CDN
+    HOLOVIEWS_AVAILABLE = True
+except ImportError:
+    HOLOVIEWS_AVAILABLE = False
+
+try:
+    from rich.panel import Panel
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+try:
+    from ipywidgets import HTML as IPyHTML
+    IPYWIDGETS_AVAILABLE = True
+except ImportError:
+    IPYWIDGETS_AVAILABLE = False
+
+
+HOLOVIEWS_SYSTEM_PROMPT = """HOLOVIEWS CHART OUTPUT MODE:
+Generate interactive charts using HoloViews (typically with Bokeh backend).
+
+REQUIREMENTS:
+1. Return Python code in a markdown code block (```python).
+2. MANDATORY: Start by importing holoviews and loading the extension:
+   ```python
+   import holoviews as hv
+   from holoviews import opts
+   hv.extension('bokeh')
+3. Store the final layout/element in a variable named 'chart', 'plot', 'layout', or 'fig'
+4. Make the chart self-contained with inline data (pandas or lists)
+5. CHART TYPES:
+    - PREFERRED: hv.Bars, hv.Curve, hv.Scatter, hv.HeatMap, hv.Histogram.
+    - FORBIDDEN: Do NOT use hv.Pie. If the user asks for a Pie chart, you MUST generate a hv.Bars chart instead.
+6. Use hv.opts for styling (width, height, tools, etc.)
+7. DO NOT execute the code or save files - return code only
+
+EXAMPLE:
+```python
+import pandas as pd
+import holoviews as hv
+from holoviews import opts
+hv.extension('bokeh')
+
+# Data
+data = pd.DataFrame({
+    'cyl': [4, 6, 8, 4, 6, 8],
+    'mpg': [30, 20, 15, 32, 21, 14]
+})
+
+# Plot
+hist = hv.Histogram(data, kdims='mpg', vdims='cyl')
+hist.opts(opts.Histogram(alpha=0.9, width=600, height=400, title="MPG Histogram"))
+
+# Assign to variable
+chart = hist
+"""
+
+@register_renderer(OutputMode.HOLOVIEWS, system_prompt=HOLOVIEWS_SYSTEM_PROMPT)
+class HoloviewsRenderer(BaseChart):
+    """Renderer for HoloViews charts (via Bokeh backend)"""
+
+    def execute_code(
+        self,
+        code: str,
+        pandas_tool: Any = None,
+        execution_state: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> Tuple[Any, Optional[str]]:
+        """Execute HoloViews code within the shared Python environment."""
+
+        if not HOLOVIEWS_AVAILABLE:
+            return None, "HoloViews or Bokeh not installed. Please install: pip install holoviews bokeh"
+
+        # Execute using BaseRenderer logic
+        context, error = super().execute_code(
+            code,
+            pandas_tool=pandas_tool,
+            execution_state=execution_state,
+            **kwargs,
+        )
+
+        if error:
+            return None, error
+
+        if not context:
+            return None, "Execution context was empty"
+
+        # Find the chart objects
+        if figures := self._find_chart_objects(context):
+            return figures, None
+
+        return None, "Code must define a HoloViews object (chart, plot, layout)"
+
+    @staticmethod
+    def _find_chart_objects(context: Dict[str, Any]) -> List[Any]:
+        """Locate all HoloViews objects in the local namespace."""
+        figures: List[Any] = []
+        seen_ids = set()
+
+        def add_fig(obj: Any) -> None:
+            if obj is None:
+                return
+
+            # Robust Check: Use isinstance if library is loaded, otherwise strict duck-typing
+            is_holoviews = False
+            if HOLOVIEWS_AVAILABLE:
+                # hv.core.Dimensioned is the base for Elements, Layouts, Overlays
+                if isinstance(obj, hv.core.Dimensioned):
+                    is_holoviews = True
+
+            # Fallback duck-typing if isinstance fails or library mix-up
+            if not is_holoviews:
+                # Relaxed duck-typing: check for 'opts' and 'kdims' OR 'data' (some containers)
+                if hasattr(obj, 'opts') and (hasattr(obj, 'kdims') or hasattr(obj, 'data')):
+                    is_holoviews = True
+
+            if is_holoviews and id(obj) not in seen_ids:
+                figures.append(obj)
+                seen_ids.add(id(obj))
+
+        # 1. Priority search for named variables
+        priority_vars = ['chart', 'plot', 'layout', 'fig', 'renderer', 'pie_chart', 'bar_chart']
+        for var_name in priority_vars:
+            if var_name in context:
+                add_fig(context[var_name])
+
+        # 2. Scan all locals for other figure objects
+        for var_name, obj in context.items():
+            if var_name.startswith('_') or var_name in priority_vars:
+                continue
+            # Skip modules and basic types to save time
+            if isinstance(obj, (int, float, str, bool, type(None))):
+                continue
+            add_fig(obj)
+
+        return figures
+
+    def _render_chart_content(self, chart_objs: Any, **kwargs) -> str:
+        """
+        Render HoloViews object to HTML/JS using Bokeh backend.
+        """
+        if not HOLOVIEWS_AVAILABLE:
+            return "<div>HoloViews library not available.</div>"
+
+        # Ensure we have a list
+        figures = chart_objs if isinstance(chart_objs, list) else [chart_objs]
+        html_parts = []
+
+        # Ensure the bokeh extension is loaded
+        try:
+            # We try to set it silent to avoid console spam
+            hv.extension('bokeh', logo=False)
+            renderer = hv.renderer('bokeh')
+        except Exception:
+            # Fallback
+            renderer = hv.renderer('bokeh')
+
+        for fig in figures:
+            try:
+                # 1. Render HoloViews object to a Bokeh plot
+                plot_state = renderer.get_plot(fig)
+
+                # 2. Generate Script and Div using Bokeh's components
+                script, div = components(plot_state.state)
+
+                # 3. Combine them
+                chart_html = f'''
+                <div class="holoviews-chart-wrapper" style="margin-bottom: 20px; display: flex; justify-content: center; flex-direction: column; align-items: center;">
+                    {div}
+                    {script}
+                </div>
+                '''
+                html_parts.append(chart_html)
+
+            except Exception as e:
+                html_parts.append(f'<div class="error" style="color:red; padding:10px;">Error rendering HoloViews chart: {str(e)}</div>')
+
+        return "\n".join(html_parts)
+
+    def _save_to_disk(self, chart_objs: Any, filename: str = None) -> str:
+        """Save chart(s) to HTML file for terminal viewing."""
+        if not filename:
+            filename = f"holoviews_{uuid.uuid4().hex[:8]}.html"
+
+        output_dir = Path("outputs/charts")
+        output_dir.mkdir(parents=True, exist_ok=True)
+        filepath = output_dir / filename
+
+        if not HOLOVIEWS_AVAILABLE:
+            return "Error: HoloViews not installed"
+
+        figures = chart_objs if isinstance(chart_objs, list) else [chart_objs]
+
+        try:
+            # Use HoloViews save method (which handles the HTML boilerplate)
+            # If multiple figures, we might want to wrap them in a Layout if possible,
+            # but saving individually or the last one is standard fallback.
+            # Here we combine them if there are multiple.
+
+            final_obj = figures[0]
+            if len(figures) > 1:
+                final_obj = hv.Layout(figures).cols(1)
+
+            hv.save(final_obj, filepath, backend='bokeh')
+            return str(filepath)
+        except Exception as e:
+            raise e
+
+    def to_html(
+        self,
+        chart_obj: Any,
+        mode: str = 'partial',
+        **kwargs
+    ) -> str:
+        """
+        Convert HoloViews chart(s) to HTML.
+        """
+        # Generate Bokeh JS/CSS resources for the <head>
+        # This is crucial for the scripts in _render_chart_content to work
+        extra_head = CDN.render() if HOLOVIEWS_AVAILABLE else ""
+
+        kwargs['extra_head'] = kwargs.get('extra_head', '') + "\n" + extra_head
+
+        return super().to_html(chart_obj, mode=mode, **kwargs)
+
+    async def render(
+        self,
+        response: Any,
+        theme: str = 'monokai',
+        environment: str = 'html',
+        include_code: bool = False,
+        html_mode: str = 'partial',
+        **kwargs
+    ) -> Tuple[Any, Optional[Any]]:
+        """Render HoloViews chart."""
+
+        # 1. Extract Code
+        code = getattr(response, 'code', None)
+        output_format = kwargs.get('output_format', environment)
+
+        if not code:
+            content = self._get_content(response)
+            code = self._extract_code(content)
+
+        if not code:
+            error_msg = "No chart code found in response"
+            if output_format == 'terminal':
+                return error_msg, None
+            return self._wrap_for_environment(
+                f"<div class='error'>{error_msg}</div>", output_format
+            ), None
+
+        # 2. Execute Code
+        chart_objs, error = self.execute_code(
+            code,
+            pandas_tool=kwargs.pop('pandas_tool', None),
+            execution_state=kwargs.pop('execution_state', None),
+            **kwargs,
+        )
+
+        if error:
+            if output_format == 'terminal':
+                return f"Error generating chart: {error}", None
+            return self._wrap_for_environment(
+                self._render_error(error, code, theme), output_format
+            ), None
+
+        # 3. Handle Terminal Environment (Save to Disk)
+        if output_format == 'terminal':
+            try:
+                saved_path = self._save_to_disk(chart_objs)
+                msg = f"Interactive HoloViews chart saved to: {saved_path}"
+                if RICH_AVAILABLE:
+                    return Panel(msg, title="📊 HoloViews Chart", border_style="green"), None
+                return msg, None
+            except Exception as e:
+                return f"Chart generated but failed to save: {e}", None
+
+        # 4. Generate HTML
+        # Pass title and other kwargs to to_html
+        html_output = self.to_html(
+            chart_objs,
+            mode=html_mode,
+            include_code=include_code,
+            code=code,
+            theme=theme,
+            title=kwargs.get('title', 'HoloViews Chart'),
+            icon='📈',
+            **kwargs
+        )
+
+        # 5. Wrap for Environment
+        if output_format in {'jupyter', 'notebook', 'ipython', 'colab'}:
+            if IPYWIDGETS_AVAILABLE:
+                return code, IPyHTML(value=html_output)
+            return code, html_output
+
+        # 6. Return default
+        return code, html_output

parrot/outputs/formats/html.py

@@ -0,0 +1,147 @@
+from typing import Any, List, Tuple, Optional
+import tempfile
+import os
+from . import register_renderer
+from .base import BaseRenderer
+from ...models.outputs import OutputMode
+
+try:
+    import panel as pn
+    from panel.pane import Markdown as PanelMarkdown
+    from panel.layout import Column
+    pn.extension('tabulator')
+    PANEL_AVAILABLE = True
+except ImportError:
+    PANEL_AVAILABLE = False
+
+
+@register_renderer(OutputMode.HTML)
+class HTMLRenderer(BaseRenderer):
+    """Renderer for HTML output using Panel or simple HTML fallback"""
+
+    async def render(
+        self,
+        response: Any,
+        **kwargs,
+    ) -> Tuple[Any, Optional[str]]:
+        """
+        Render response as HTML, returning a primary content object and a wrapped HTML string.
+        """
+        use_panel = kwargs.get('use_panel', True) and PANEL_AVAILABLE
+
+        if use_panel:
+            dashboard = self._render_with_panel(response, **kwargs)
+            html_string = self._panel_to_html(dashboard)
+            content = dashboard
+            wrapped = html_string
+        else:
+            html_string = self._render_simple_html(response, **kwargs)
+            content = html_string
+            wrapped = html_string
+
+        return content, wrapped
+
+    def _render_with_panel(self, response: Any, **kwargs) -> Any:
+        """
+        Format output as an interactive Panel dashboard.
+        """
+        components = self._build_panel_components(response, **kwargs)
+        return Column(*components, sizing_mode='stretch_width', styles={'background': '#ffffff', 'padding': '20px'})
+
+    def _build_panel_components(self, response: Any, **kwargs) -> list:
+        show_metadata = kwargs.get('show_metadata', True)
+        show_sources = kwargs.get('show_sources', True)
+        show_tools = kwargs.get('show_tools', False)
+        components = []
+
+        if content := self._get_content(response):
+            components.extend([
+                pn.pane.HTML("<h2>🤖 Response</h2>"),
+                PanelMarkdown(
+                    content, sizing_mode='stretch_width',
+                    styles={'background': '#f0f8ff', 'padding': '20px', 'border-radius': '5px'}
+                )
+            ])
+        if show_tools and hasattr(response, 'tool_calls') and response.tool_calls:
+            tools_df = self._create_tools_dataframe(response.tool_calls)
+            components.extend([
+                pn.pane.HTML("<h3>🔧 Tool Calls</h3>"),
+                pn.widgets.Tabulator(tools_df, sizing_mode='stretch_width', theme='modern', show_index=False)
+            ])
+        if show_metadata:
+            metadata_html = self._create_metadata_panel(response)
+            components.extend([pn.pane.HTML("<h3>📊 Metadata</h3>"), pn.pane.HTML(metadata_html)])
+        if show_sources and hasattr(response, 'source_documents') and response.source_documents:
+            sources_df = self._create_sources_dataframe(response.source_documents)
+            components.extend([
+                pn.pane.HTML("<h3>📄 Sources</h3>"),
+                pn.widgets.Tabulator(sources_df, sizing_mode='stretch_width', theme='modern', show_index=False)
+            ])
+        return components
+
+    def _panel_to_html(self, dashboard: Any) -> str:
+        """Convert Panel dashboard to an HTML string."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.html', delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            dashboard.save(tmp_path, embed=True)
+            with open(tmp_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        finally:
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+
+    def _create_tools_dataframe(self, tool_calls: List[Any]):
+        import pandas as pd
+        return pd.DataFrame([
+            {'#': idx, 'Tool Name': getattr(tool, 'name', 'Unknown'), 'Status': getattr(tool, 'status', 'completed')}
+            for idx, tool in enumerate(tool_calls, 1)
+        ])
+
+    def _create_sources_dataframe(self, sources: List[Any]):
+        import pandas as pd
+        return pd.DataFrame([
+            {
+                '#': idx,
+                'Source': getattr(source, 'source', source.get('source', 'Unknown')),
+                'Score': f"{getattr(source, 'score', source.get('score', 'N/A')):.4f}"
+            }
+            for idx, source in enumerate(sources, 1)
+        ])
+
+    def _create_metadata_panel(self, response: Any) -> str:
+        items = []
+        if hasattr(response, 'model'):
+            items.append(f"<div class='metadata-item'><span class='key'>Model:</span> <span class='value'>{response.model}</span></div>")
+        return f"<div class='metadata-container'>{''.join(items)}</div>"
+
+    def _render_simple_html(self, response: Any, **kwargs) -> str:
+        """Format output as a simple HTML string."""
+        html_parts = [self._get_html_header()]
+        if content := self._get_content(response):
+            html_parts.append(f"<div class='ap-response-container'><h2>🤖 Response</h2><div class='ap-content'>{self._markdown_to_html(content)}</div></div>")
+        if kwargs.get('show_tools', False) and hasattr(response, 'tool_calls') and response.tool_calls:
+            html_parts.append(f"<div class='ap-section'><h3>🔧 Tool Calls</h3>{self._create_tools_html(response.tool_calls)}</div>")
+        html_parts.append('</body></html>')
+        return '\n'.join(html_parts)
+
+    def _get_html_header(self) -> str:
+        return '''
+        <!DOCTYPE html><html><head><title>AI Response</title>
+        <style>.ap-html-wrapper { font-family: sans-serif; } .ap-response-container { background: #f0f8ff; }</style>
+        </head><body class="ap-html-wrapper">
+        '''
+
+    def _markdown_to_html(self, content: str) -> str:
+        try:
+            import markdown
+            return markdown.markdown(content, extensions=['fenced_code', 'tables', 'nl2br'])
+        except ImportError:
+            return f"<p>{content.replace(chr(10), '<br>')}</p>"
+
+    def _create_tools_html(self, tool_calls: List[Any]) -> str:
+        rows = "".join(
+            f"<tr><td><strong>{idx}</strong></td><td>{getattr(tool, 'name', 'Unknown')}</td><td><span class='badge'>completed</span></td></tr>"
+            for idx, tool in enumerate(tool_calls, 1)
+        )
+        return f"<table><thead><tr><th>#</th><th>Tool Name</th><th>Status</th></tr></thead><tbody>{rows}</tbody></table>"

parrot/outputs/formats/jinja2.py

@@ -0,0 +1,46 @@
+import mimetypes
+from typing import Any, Tuple
+
+from jinja2 import Environment
+
+from ...models.outputs import OutputMode
+from . import register_renderer
+from .base import BaseRenderer
+
+
+@register_renderer(OutputMode.JINJA2)
+class Jinja2Renderer(BaseRenderer):
+    """
+    Renders the output using a Jinja2 template.
+    """
+
+    async def render(self, data: Any, **kwargs: Any) -> Tuple[str, str]:
+        """
+        Renders data using a Jinja2 template asynchronously.
+
+        Args:
+            data: The data to render.
+            **kwargs: Must contain 'env' (a Jinja2 Environment) and 'template' (the template name).
+
+        Returns:
+            A tuple containing the rendered content and the guessed MIME type.
+        """
+        env: Environment = kwargs.get("env")
+        if not env:
+            raise ValueError("Jinja2 environment not provided in kwargs.")
+
+        template_name: str = kwargs.get("template")
+        if not template_name:
+            raise ValueError("Jinja2 template name not provided in kwargs.")
+
+        try:
+            template = env.get_template(template_name)
+        except Exception as e:
+            raise ValueError(
+                f"Failed to load Jinja2 template '{template_name}': {e}"
+            ) from e
+
+        content_type = mimetypes.guess_type(template_name)[0] or "text/plain"
+
+        rendered_content = await template.render_async(**data)
+        return rendered_content, content_type

parrot/outputs/formats/json.py

@@ -0,0 +1,87 @@
+from typing import Any, Tuple, Optional
+from . import register_renderer
+from .base import BaseRenderer
+from ...models.outputs import OutputMode
+
+
+@register_renderer(OutputMode.JSON)
+class JSONRenderer(BaseRenderer):
+    """
+    Renderer for JSON output.
+    Handles PandasAgentResponse, DataFrames, Pydantic models, and generic content.
+    Adapts output format to Terminal (Rich), HTML (Pygments), and Jupyter (Widgets).
+    """
+    async def render(
+        self,
+        response: Any,
+        environment: str = 'default',
+        **kwargs,
+    ) -> Tuple[Any, Optional[Any]]:
+        """
+        Render response as JSON.
+
+        Returns:
+            Tuple[str, Any]: (json_string, wrapped_content)
+        """
+        indent = kwargs.get('indent')
+        output_format = kwargs.get('output_format', environment)
+
+        # 1. Extract Data
+        data = self._extract_data(response)
+
+        # 2. Serialize to content string
+        json_string = self._serialize(data, indent=indent)
+
+        # 3. Wrap content based on environment
+        wrapped_output = self._wrap_output(json_string, data, output_format)
+
+        return json_string, wrapped_output
+
+    def _wrap_output(self, json_string: str, data: Any, environment: str) -> Any:
+        """
+        Wrap the JSON string into an environment-specific container.
+        """
+        if environment == 'terminal':
+            try:
+                from rich.panel import Panel
+                from rich.syntax import Syntax
+                from rich.json import JSON as RichJSON
+
+                # Use Rich's native JSON rendering if possible for better formatting
+                return Panel(
+                    RichJSON(json_string),
+                    title="JSON Output",
+                    border_style="green"
+                )
+            except ImportError:
+                return json_string
+
+        elif environment in {'jupyter', 'notebook'}:
+            try:
+                # For Jupyter, we try to return a Widget or specialized display object
+                # Method A: ipywidgets (Interactive)
+                from ipywidgets import HTML
+
+                # Create formatted HTML for the JSON
+                from pygments import highlight
+                from pygments.lexers import JsonLexer
+                from pygments.formatters import HtmlFormatter
+
+                formatter = HtmlFormatter(style='colorful', noclasses=True)
+                highlighted_html = highlight(json_string, JsonLexer(), formatter)
+
+                # Wrap in a widget
+                widget = HTML(
+                    value=f'<div style="max-height: 500px; overflow-y: auto; background-color: #f8f8f8; padding: 10px;">{highlighted_html}</div>'
+                )
+                return widget
+
+            except ImportError:
+                # Fallback to HTML representation if widgets not available
+                return self._wrap_html(json_string)
+
+        elif environment == 'html':
+            return self._wrap_html(json_string)
+
+        # Default / Text
+        return json_string