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

parrot/outputs/formats/markdown.py

@@ -0,0 +1,172 @@
+from typing import Any, Optional, Tuple
+import html as html_module
+import markdown
+from markdown.extensions.codehilite import CodeHiliteExtension
+from . import register_renderer
+from .base import BaseRenderer
+from ...models.outputs import OutputMode
+
+try:
+    from rich.console import Console
+    from rich.markdown import Markdown as RichMarkdown
+    from rich.panel import Panel as RichPanel
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+try:
+    from ipywidgets import HTML as IPyHTML
+    IPYWIDGETS_AVAILABLE = True
+except ImportError:
+    IPYWIDGETS_AVAILABLE = False
+
+try:
+    import panel as pn
+    from panel.pane import Markdown as PanelMarkdown
+    PANEL_AVAILABLE = True
+except ImportError:
+    PANEL_AVAILABLE = False
+
+try:
+    from IPython.display import Markdown as IPythonMarkdown
+    IPYTHON_AVAILABLE = True
+except ImportError:
+    IPYTHON_AVAILABLE = False
+
+
+@register_renderer(OutputMode.MARKDOWN, system_prompt="MARKDOWN OUTPUT MODE: **IMPORTANT** Generate markdown formatted text.")
+class MarkdownRenderer(BaseRenderer):
+    """
+    Renderer for Markdown output.
+    Handles PandasAgentResponse (explanation), AIMessage, and generic text.
+    Adapts output format to Terminal (Rich), HTML, Jupyter, and Panel.
+    """
+    def _extract_content(self, response: Any) -> str:
+        """
+        Extract Markdown text content based on response type rules.
+        """
+        # 1. Check for PandasAgentResponse (duck typing)
+        # We check for specific attributes that define a PandasAgentResponse
+        output = getattr(response, 'output', None)
+
+        if output is not None:
+            # Handle PandasAgentResponse: The 'explanation' is usually the markdown text
+            if hasattr(output, 'explanation') and output.explanation:
+                return str(output.explanation)
+
+            # If it has a 'response' attribute (some agent responses)
+            if hasattr(output, 'response') and output.response:
+                return str(output.response)
+
+        # 2. Check standard AIMessage response text
+        if hasattr(response, 'response') and response.response:
+            return str(response.response)
+
+        # 3. Fallback: Use output if string, or stringify
+        if output is not None:
+            return output if isinstance(output, str) else str(output)
+
+        # 4. Last resort: stringify the whole response object
+        return str(response)
+
+    async def render(
+        self,
+        response: Any,
+        environment: str = 'default',
+        **kwargs,
+    ) -> Tuple[str, Any]:
+        """
+        Render markdown content.
+        """
+        # 1. Extract Content
+        content = self._extract_content(response)
+
+        # 2. Determine Format
+        # Allow overriding format via kwargs, else default to environment
+        output_format = kwargs.get('format') or kwargs.get('output_format', environment)
+
+        # 3. Wrap content based on environment/format
+        wrapped_output = self._wrap_output(content, output_format, **kwargs)
+
+        return content, wrapped_output
+
+    def _wrap_output(self, content: str, environment: str, **kwargs) -> Any:
+        """
+        Wrap the Markdown content into an environment-specific container.
+        """
+        # --- Terminal (Rich) ---
+        if environment == 'terminal':
+            if RICH_AVAILABLE:
+                show_panel = kwargs.get('show_panel', True)
+                panel_title = kwargs.get('panel_title', "📝 Response")
+
+                console = Console(force_terminal=True)
+                md = RichMarkdown(content)
+
+                # Capture rich output to string/object
+                with console.capture() as capture:
+                    if show_panel:
+                        console.print(RichPanel(md, title=panel_title, border_style="blue", expand=False))
+                    else:
+                        console.print(md)
+                return capture.get()
+            return content
+
+        # --- Jupyter / Notebook ---
+        elif environment in ('jupyter', 'notebook', 'colab'):
+            # Priority 1: Panel (if requested or available and appropriate)
+            if environment == 'panel' or (kwargs.get('use_panel', False) and PANEL_AVAILABLE):
+                styles = kwargs.get('styles', {
+                    'background': '#f9f9f9', 'padding': '20px', 'border-radius': '5px',
+                    'box-shadow': '0 2px 4px rgba(0,0,0,0.1)'
+                })
+                return PanelMarkdown(content, sizing_mode='stretch_width', styles=styles)
+
+            # Priority 2: IPyWidgets (if interactive requested)
+            use_widget = kwargs.get('use_widget', False)
+            if use_widget and IPYWIDGETS_AVAILABLE:
+                html_content = self._markdown_to_html(content)
+                return IPyHTML(value=html_content)
+
+            # Priority 3: Standard IPython Display
+            if IPYTHON_AVAILABLE:
+                return IPythonMarkdown(content)
+
+            # Fallback
+            return self._markdown_to_html(content)
+
+        # --- HTML ---
+        elif environment == 'html':
+            return self._markdown_to_html(content)
+
+        # --- Default / Plain ---
+        return content
+
+    def _markdown_to_html(self, content: str) -> str:
+        """Convert markdown to HTML with syntax highlighting."""
+        try:
+            html = markdown.markdown(
+                content,
+                extensions=[
+                    'fenced_code', 'tables', 'nl2br',
+                    CodeHiliteExtension(css_class='highlight', linenums=False)
+                ]
+            )
+            # Add basic styling for the HTML output
+            return f'''
+            <div class="markdown-content" style="line-height: 1.6;">
+                <style>
+                    .markdown-content h1, .markdown-content h2, .markdown-content h3 {{ margin-top: 1.5em; }}
+                    .markdown-content code {{ background: #f4f4f4; padding: 2px 6px; border-radius: 3px; font-family: monospace; }}
+                    .markdown-content pre {{ background: #2d2d2d; color: #f8f8f2; padding: 15px; border-radius: 5px; overflow-x: auto; }}
+                    .markdown-content table {{ border-collapse: collapse; width: 100%; margin: 1em 0; }}
+                    .markdown-content th, .markdown-content td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
+                    .markdown-content th {{ background-color: #f2f2f2; }}
+                </style>
+                {html}
+            </div>
+            '''
+        except ImportError:
+            # Fallback if markdown lib is missing
+            escaped = html_module.escape(content)
+            return f'<pre style="white-space: pre-wrap; font-family: sans-serif;">{escaped}</pre>'

parrot/outputs/formats/matplotlib.py

@@ -0,0 +1,237 @@
+from typing import Any, Optional, Tuple, Dict
+import io
+import base64
+import uuid
+from pathlib import Path
+from .chart import BaseChart
+from . import register_renderer
+from ...models.outputs import OutputMode
+
+try:
+    from rich.panel import Panel
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+
+MATPLOTLIB_SYSTEM_PROMPT = """MATPLOTLIB CHART OUTPUT MODE:
+Generate a chart using Matplotlib.
+
+REQUIREMENTS:
+1. Return Python code in a markdown code block (```python)
+2. Use matplotlib.pyplot (import matplotlib.pyplot as plt)
+3. Store the figure in a variable named 'fig' or use plt.gcf()
+4. Make the chart self-contained with inline data
+5. Use appropriate plot types (plot, bar, scatter, hist, pie, etc.)
+6. Add titles, labels, legends, and grid for clarity
+7. Use plt.tight_layout() for better spacing
+8. DO NOT call plt.show() or save files - return code only
+
+EXAMPLE:
+```python
+import matplotlib.pyplot as plt
+import numpy as np
+
+categories = ['A', 'B', 'C', 'D']
+values = [23, 45, 12, 67]
+
+fig, ax = plt.subplots(figsize=(10, 6))
+ax.bar(categories, values, color='steelblue')
+ax.set_title('Sales by Category', fontsize=16, fontweight='bold')
+ax.set_xlabel('Category')
+ax.set_ylabel('Sales')
+ax.grid(axis='y', alpha=0.3)
+plt.tight_layout()
+```
+"""
+
+
+@register_renderer(OutputMode.MATPLOTLIB, system_prompt=MATPLOTLIB_SYSTEM_PROMPT)
+class MatplotlibRenderer(BaseChart):
+    """Renderer for Matplotlib charts"""
+
+    def execute_code(
+        self,
+        code: str,
+        pandas_tool: Any = None,
+        execution_state: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> Tuple[Any, Optional[str]]:
+        """Execute Matplotlib code within the shared Python environment."""
+        extra_namespace = None
+        # If no pandas tool is provided, we need to setup the backend manually
+        # to ensure we don't try to open a GUI window
+        manual_backend = pandas_tool is None
+
+        if manual_backend:
+            import matplotlib
+            matplotlib.use('Agg')
+            import matplotlib.pyplot as plt
+            extra_namespace = {'plt': plt, 'matplotlib': matplotlib}
+
+        context, error = super().execute_code(
+            code,
+            pandas_tool=pandas_tool,
+            execution_state=execution_state,
+            extra_namespace=extra_namespace,
+            **kwargs,
+        )
+
+        try:
+            if error:
+                return None, error
+
+            if not context:
+                return None, "Execution context was empty"
+
+            # Try to find the figure object in the context
+            fig = context.get('fig') or context.get('figure')
+
+            # Fallback: get current figure if available
+            if fig is None:
+                if 'plt' in context:
+                    fig = context['plt'].gcf()
+                elif not manual_backend and pandas_tool:
+                    # Try to get plt from tool locals if available
+                    plt_ref = pandas_tool.locals.get('plt')
+                    if plt_ref:
+                        fig = plt_ref.gcf()
+
+            if fig is None or not hasattr(fig, 'savefig'):
+                return None, "Code must create a matplotlib figure (fig) or use plt functions"
+
+            return fig, None
+        finally:
+            # Cleanup to avoid memory leaks
+            if manual_backend and 'plt' in locals():
+                try:
+                    plt.close('all')
+                except Exception:
+                    pass
+
+    def _render_chart_content(self, chart_obj: Any, **kwargs) -> str:
+        """Render Matplotlib chart as base64 embedded image."""
+        img_id = f"matplotlib-chart-{uuid.uuid4().hex[:8]}"
+
+        # Get image format and DPI
+        img_format = kwargs.get('format', 'png')
+        dpi = kwargs.get('dpi', 100)
+
+        # Save figure to bytes buffer
+        buf = io.BytesIO()
+        chart_obj.savefig(buf, format=img_format, dpi=dpi, bbox_inches='tight')
+        buf.seek(0)
+
+        # Encode to base64
+        img_base64 = base64.b64encode(buf.read()).decode('utf-8')
+        buf.close()
+
+        # Create img tag with base64 data
+        return f'''
+        <img id="{img_id}"
+            src="data:image/{img_format};base64,{img_base64}"
+            style="max-width: 100%; height: auto; display: block; margin: 0 auto; border-radius: 4px;"
+            alt="Matplotlib Chart" />
+        '''
+
+    def to_html(
+        self,
+        chart_obj: Any,
+        mode: str = 'partial',
+        **kwargs
+    ) -> str:
+        """
+        Convert Matplotlib chart to HTML.
+        """
+        # Matplotlib doesn't need external scripts in head
+        kwargs['extra_head'] = kwargs.get('extra_head', '')
+
+        # Call parent to_html
+        return super().to_html(chart_obj, mode=mode, **kwargs)
+
+    def to_json(self, chart_obj: Any) -> Optional[Dict]:
+        """Matplotlib figures don't have a standard native JSON representation."""
+        return None
+
+    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 Matplotlib chart."""
+
+        # 1. Extract Code
+        # Check if code is explicitly provided in the structured response
+        code = getattr(response, 'code', None)
+
+        output_format = kwargs.get('output_format', environment)
+
+        # Fallback to extracting from text content
+        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_obj, 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':
+            saved_path = self._save_to_disk(chart_obj)
+            msg = f"Chart generated successfully and saved to: {saved_path}"
+
+            if RICH_AVAILABLE:
+                return Panel(msg, title="📊 Chart Generated", border_style="green"), None
+            return msg, None
+
+        # 4. Generate HTML for Web/Jupyter
+        html_output = self.to_html(
+            chart_obj,
+            mode=html_mode,
+            include_code=include_code,
+            code=code,
+            theme=theme,
+            title=kwargs.pop('title', 'Matplotlib Chart'),
+            icon='📈',
+            dpi=kwargs.pop('dpi', 100),
+            format=kwargs.pop('img_format', 'png'),
+            **kwargs
+        )
+
+        # 5. Wrap for Environment
+        if output_format in {'jupyter', 'notebook', 'ipython', 'colab'}:
+            wrapped_html = self._wrap_for_environment(html_output, output_format)
+        else:
+            wrapped_html = html_output
+
+        # 6. Return based on output format
+        if output_format == 'html':
+            return None, wrapped_html
+        else:
+            # Default behavior: Return code as content, HTML widget as wrapped
+            return code, wrapped_html