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

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

@@ -1,171 +0,0 @@
-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 PythonCommandRunTool(ToolBase):
-    """
-    Tool to execute Python code using the `python -c` command-line flag.
-
-    Args:
-        code (str): The Python code to execute as a string.
-        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_command_run"
-
-    def run(self, code: str, timeout: int = 60, silent: bool = False) -> str:
-        if not code.strip():
-            self.report_warning(tr("ℹ️ Empty code provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty code provided. Operation skipped.")
-        if not silent:
-            self.report_action(
-                tr("🐍 Running: python -c ...\n{code}\n", code=code),
-                ReportAction.EXECUTE,
-            )
-            self.report_stdout("\n")
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_cmd_stdout_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_cmd_stderr_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stderr_file,
-            ):
-                process = subprocess.Popen(
-                    [sys.executable, "-c", code],
-                    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 code: {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()
-                from janito.tools.tool_base 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_command_run: STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- python_command_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_command_run: STDOUT (head/tail) ---\n"
-                + head_tail(stdout_content)
-                + "\n"
-            )
-            if stderr_content.strip():
-                result += (
-                    "--- python_command_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/pythondev/tools/python_file_run.py

@@ -1,172 +0,0 @@
-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

@@ -1,23 +0,0 @@
-"""
-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

@@ -1,259 +0,0 @@
-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}"