janito 3.2.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

janito/plugins_backup_20250825_070018/dev/pythondev/tools/python_file_run.py

@@ -0,0 +1,172 @@
+import subprocess
+import os
+import sys
+import tempfile
+import threading
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.i18n import tr
+
+
+@register_local_tool
+class PythonFileRunTool(ToolBase):
+    """
+    Tool to execute a specified Python script file.
+
+    Args:
+        path (str): Path to the Python script file to execute.
+        timeout (int): Timeout in seconds for the command. Defaults to 60.
+        silent (bool): If True, suppresses progress and status messages. Defaults to False.
+
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    permissions = ToolPermissions(execute=True)
+    tool_name = "python_file_run"
+
+    def run(self, path: str, timeout: int = 60, silent: bool = False) -> str:
+        from janito.tools.path_utils import expand_path
+
+        path = expand_path(path)
+        if not silent:
+            self.report_action(
+                tr("🚀 Running: python {path}", path=path),
+                ReportAction.EXECUTE,
+            )
+            self.report_stdout("\n")
+        else:
+            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_file_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_file_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [sys.executable, path],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
+                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                )
+                stdout_lines, stderr_lines = self._stream_process_output(
+                    process, stdout_file, stderr_file
+                )
+                return_code = self._wait_for_process(process, timeout)
+                if return_code is None:
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_file.flush()
+                stderr_file.flush()
+                if not silent:
+                    self.report_success(
+                        tr("✅ Return code {return_code}", return_code=return_code),
+                        ReportAction.EXECUTE,
+                    )
+                return self._format_result(
+                    stdout_file.name, stderr_file.name, return_code
+                )
+        except Exception as e:
+            self.report_error(tr("❌ Error: {error}", error=e), ReportAction.EXECUTE)
+            return tr("Error running file: {error}", error=e)
+
+    def _stream_process_output(self, process, stdout_file, stderr_file):
+        stdout_lines = 0
+        stderr_lines = 0
+
+        def stream_output(stream, file_obj, report_func, count_func):
+            nonlocal stdout_lines, stderr_lines
+            for line in stream:
+                file_obj.write(line)
+                file_obj.flush()
+                # Always supply a default action for stdout/stderr reporting
+                from janito.report_events import ReportAction
+
+                report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
+                if count_func == "stdout":
+                    stdout_lines += 1
+                else:
+                    stderr_lines += 1
+
+        stdout_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+        stdout_thread.join()
+        stderr_thread.join()
+        return stdout_lines, stderr_lines
+
+    def _wait_for_process(self, process, timeout):
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.report_error(
+                tr("❌ Timed out after {timeout} seconds.", timeout=timeout),
+                ReportAction.EXECUTE,
+            )
+            return None
+
+    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
+        with open(stdout_file_name, "r", encoding="utf-8", errors="replace") as out_f:
+            stdout_content = out_f.read()
+        with open(stderr_file_name, "r", encoding="utf-8", errors="replace") as err_f:
+            stderr_content = err_f.read()
+        max_lines = 100
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+
+        def head_tail(text, n=10):
+            lines = text.splitlines()
+            if len(lines) <= 2 * n:
+                return "\n".join(lines)
+            return "\n".join(
+                lines[:n]
+                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                + lines[-n:]
+            )
+
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = f"Return code: {return_code}\n--- python_file_run: STDOUT ---\n{stdout_content}"
+            if stderr_content.strip():
+                result += f"\n--- python_file_run: STDERR ---\n{stderr_content}"
+            return result
+        else:
+            result = f"stdout_file: {stdout_file_name} (lines: {stdout_lines})\n"
+            if stderr_lines > 0 and stderr_content.strip():
+                result += f"stderr_file: {stderr_file_name} (lines: {stderr_lines})\n"
+            result += f"returncode: {return_code}\n"
+            result += (
+                "--- python_file_run: STDOUT (head/tail) ---\n"
+                + head_tail(stdout_content)
+                + "\n"
+            )
+            if stderr_content.strip():
+                result += (
+                    "--- python_file_run: STDERR (head/tail) ---\n"
+                    + head_tail(stderr_content)
+                    + "\n"
+                )
+            result += "Use the view_file tool to inspect the contents of these files when needed."
+            return result

janito/plugins_backup_20250825_070018/dev/visualization/__init__.py

@@ -0,0 +1,23 @@
+"""
+Visualization Plugin
+
+Data visualization and charting tools.
+"""
+
+from typing import Dict, Any
+
+
+def read_chart(
+    data: Dict[str, Any], title: str = "Chart", width: int = 80, height: int = 20
+) -> str:
+    """Display charts in terminal (bar, line, pie, table)"""
+    return f"read_chart(type='{data.get('type')}', title='{title}')"
+
+
+read_chart.tool_name = "read_chart"
+
+
+# Plugin metadata
+__plugin_name__ = "dev.visualization"
+__plugin_description__ = "Data visualization and charts"
+__plugin_tools__ = [read_chart]

janito/plugins_backup_20250825_070018/dev/visualization/tools/read_chart.py

@@ -0,0 +1,259 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import display_path
+from janito.i18n import tr
+import json
+import os
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class ReadChartTool(ToolBase):
+    """
+    Display charts and data visualizations in the terminal using rich.
+
+    Args:
+        data (dict): Chart data in JSON format. Should contain 'type' (bar, line, pie, table) and 'data' keys.
+        title (str, optional): Chart title. Defaults to "Chart".
+        width (int, optional): Chart width. Defaults to 80.
+        height (int, optional): Chart height. Defaults to 20.
+
+    Returns:
+        str: Formatted chart display in terminal or error message.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "read_chart"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="data")
+    def run(
+        self, data: dict, title: str = "Chart", width: int = 80, height: int = 20
+    ) -> str:
+        try:
+            from rich.console import Console
+            from rich.table import Table
+            from rich.text import Text
+            from rich.layout import Layout
+            from rich.panel import Panel
+            from rich.columns import Columns
+            from rich import box
+
+            console = Console(width=width)
+
+            if not isinstance(data, dict):
+                return "❌ Error: Data must be a dictionary"
+
+            chart_type = data.get("type", "table").lower()
+            chart_data = data.get("data", [])
+
+            if not chart_data:
+                return "⚠️ Warning: No data provided for chart"
+
+            self.report_action(
+                tr(
+                    "📊 Displaying {chart_type} chart: {title}",
+                    chart_type=chart_type,
+                    title=title,
+                ),
+                ReportAction.READ,
+            )
+
+            if chart_type == "table":
+                return self._display_table(console, chart_data, title, width)
+            elif chart_type == "bar":
+                return self._display_bar(console, chart_data, title, width, height)
+            elif chart_type == "line":
+                return self._display_line(console, chart_data, title, width, height)
+            elif chart_type == "pie":
+                return self._display_pie(console, chart_data, title, width)
+            else:
+                return f"❌ Error: Unsupported chart type '{chart_type}'. Use: table, bar, line, pie"
+
+        except ImportError:
+            return "❌ Error: rich library not available for chart display"
+        except Exception as e:
+            return f"❌ Error displaying chart: {e}"
+
+    def _display_table(self, console, data, title, width):
+        """Display data as a rich table."""
+        from rich.table import Table
+
+        if not data:
+            return "No data to display"
+
+        table = Table(title=title, show_header=True, header_style="bold magenta")
+
+        # Handle different data formats
+        if isinstance(data, dict):
+            # Dictionary format: key-value pairs
+            table.add_column("Key", style="cyan")
+            table.add_column("Value", style="green")
+            for key, value in data.items():
+                table.add_row(str(key), str(value))
+        elif isinstance(data, list):
+            if data and isinstance(data[0], dict):
+                # List of dictionaries (records)
+                headers = list(data[0].keys()) if data else []
+                for header in headers:
+                    table.add_column(str(header).title(), style="cyan")
+                for row in data:
+                    table.add_row(*[str(row.get(h, "")) for h in headers])
+            else:
+                # Simple list
+                table.add_column("Items", style="cyan")
+                for item in data:
+                    table.add_row(str(item))
+
+        console.print(table)
+        return f"✅ Table chart displayed: {title}"
+
+    def _display_bar(self, console, data, title, width, height):
+        """Display data as a simple bar chart using unicode blocks."""
+        try:
+            if isinstance(data, dict):
+                items = list(data.items())
+            elif isinstance(data, list) and data and isinstance(data[0], dict):
+                # Assume first two keys are labels and values
+                keys = list(data[0].keys())
+                if len(keys) >= 2:
+                    label_key, value_key = keys[0], keys[1]
+                    items = [(item[label_key], item[value_key]) for item in data]
+                else:
+                    items = [(str(i), v) for i, v in enumerate(data)]
+            else:
+                items = [(str(i), v) for i, v in enumerate(data)]
+
+            if not items:
+                return "No data to display"
+
+            # Convert values to numbers
+            numeric_items = []
+            for label, value in items:
+                try:
+                    numeric_items.append((str(label), float(value)))
+                except (ValueError, TypeError):
+                    numeric_items.append((str(label), 0.0))
+
+            if not numeric_items:
+                return "No valid numeric data to display"
+
+            max_val = max(val for _, val in numeric_items) if numeric_items else 1
+
+            console.print(f"\n[bold]{title}[/bold]")
+            console.print("=" * min(len(title), width))
+
+            for label, value in numeric_items:
+                bar_length = int((value / max_val) * (width - 20)) if max_val > 0 else 0
+                bar = "█" * bar_length
+                console.print(f"{label:<15} {bar} {value:.1f}")
+
+            return f"✅ Bar chart displayed: {title}"
+
+        except Exception as e:
+            return f"❌ Error displaying bar chart: {e}"
+
+    def _display_line(self, console, data, title, width, height):
+        """Display data as a simple line chart using unicode characters."""
+        try:
+            if isinstance(data, dict):
+                items = list(data.items())
+            elif isinstance(data, list):
+                if data and isinstance(data[0], dict):
+                    keys = list(data[0].keys())
+                    if len(keys) >= 2:
+                        label_key, value_key = keys[0], keys[1]
+                        items = [(item[label_key], item[value_key]) for item in data]
+                    else:
+                        items = [(str(i), v) for i, v in enumerate(data)]
+                else:
+                    items = [(str(i), v) for i, v in enumerate(data)]
+            else:
+                return "Unsupported data format"
+
+            # Convert to numeric values
+            points = []
+            for x, y in items:
+                try:
+                    points.append((float(x), float(y)))
+                except (ValueError, TypeError):
+                    continue
+
+            if len(points) < 2:
+                return "Need at least 2 data points for line chart"
+
+            points.sort(key=lambda p: p[0])
+
+            # Simple ASCII line chart
+            min_x, max_x = min(p[0] for p in points), max(p[0] for p in points)
+            min_y, max_y = min(p[1] for p in points), max(p[1] for p in points)
+
+            if max_x == min_x or max_y == min_y:
+                return "Cannot display line chart: all values are the same"
+
+            console.print(f"\n[bold]{title}[/bold]")
+            console.print("=" * min(len(title), width))
+
+            # Simple representation
+            for x, y in points:
+                x_norm = int(((x - min_x) / (max_x - min_x)) * (width - 20))
+                y_norm = int(((y - min_y) / (max_y - min_y)) * 10)
+                line = " " * x_norm + "●" + " " * (width - 20 - x_norm)
+                console.print(f"{x:>8.1f}: {line} {y:.1f}")
+
+            return f"✅ Line chart displayed: {title}"
+
+        except Exception as e:
+            return f"❌ Error displaying line chart: {e}"
+
+    def _display_pie(self, console, data, title, width):
+        """Display data as a simple pie chart representation."""
+        try:
+            if isinstance(data, dict):
+                items = list(data.items())
+            elif isinstance(data, list) and data and isinstance(data[0], dict):
+                keys = list(data[0].keys())
+                if len(keys) >= 2:
+                    label_key, value_key = keys[0], keys[1]
+                    items = [(item[label_key], item[value_key]) for item in data]
+                else:
+                    items = [(str(i), v) for i, v in enumerate(data)]
+            else:
+                items = [(str(i), v) for i, v in enumerate(data)]
+
+            # Convert to numeric values
+            values = []
+            for label, value in items:
+                try:
+                    values.append((str(label), float(value)))
+                except (ValueError, TypeError):
+                    continue
+
+            if not values:
+                return "No valid numeric data to display"
+
+            total = sum(val for _, val in values)
+            if total == 0:
+                return "Cannot display pie chart: total is zero"
+
+            console.print(f"\n[bold]{title}[/bold]")
+            console.print("=" * min(len(title), width))
+
+            # Unicode pie chart segments
+            segments = ["🟦", "🟥", "🟩", "🟨", "🟪", "🟧", "⬛", "⬜"]
+
+            for i, (label, value) in enumerate(values):
+                percentage = (value / total) * 100
+                segment = segments[i % len(segments)]
+                bar_length = int((value / total) * (width - 30))
+                bar = "█" * bar_length
+                console.print(
+                    f"{segment} {label:<15} {bar} {percentage:5.1f}% ({value})"
+                )
+
+            console.print(f"\n[dim]Total: {total}[/dim]")
+
+            return f"✅ Pie chart displayed: {title}"
+
+        except Exception as e:
+            return f"❌ Error displaying pie chart: {e}"