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

janito/plugins_backup_20250825_070018/tools/read_chart.py

@@ -1,259 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.plugins.tools.decorators import register_core_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_core_tool
-class ReadChart(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}"

janito/plugins_backup_20250825_070018/tools/read_files.py

@@ -1,58 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.plugins.tools.decorators import register_core_tool
-from janito.tools.tool_utils import pluralize
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_core_tool
-class ReadFiles(ToolBase):
-    """
-    Read all text content from multiple files.
-
-    Args:
-        paths (list[str]): List of file paths to read.
-
-    Returns:
-        str: Concatenated content of all files, each prefixed by a header with the file name. If a file cannot be read, an error message is included for that file.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "read_files"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
-    def run(self, paths: list[str]) -> str:
-        from janito.tools.tool_utils import display_path
-        import os
-        from janito.tools.path_utils import expand_path
-
-        results = []
-        for path in [expand_path(p) for p in paths]:
-            disp_path = display_path(path)
-            self.report_action(
-                tr("📖 Read '{disp_path}'", disp_path=disp_path), ReportAction.READ
-            )
-            if not os.path.isfile(path):
-                self.report_warning(
-                    tr("❗ not found: {disp_path}", disp_path=disp_path)
-                )
-                results.append(f"--- File: {disp_path} (not found) ---\n")
-                continue
-            try:
-                with open(path, "r", encoding="utf-8", errors="replace") as f:
-                    content = f.read()
-                results.append(f"--- File: {disp_path} ---\n{content}\n")
-                self.report_success(tr("✅ Read {disp_path}", disp_path=disp_path))
-            except Exception as e:
-                self.report_error(
-                    tr(
-                        " ❌ Error reading {disp_path}: {error}",
-                        disp_path=disp_path,
-                        error=e,
-                    )
-                )
-                results.append(
-                    f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
-                )
-        return "\n".join(results)

janito/plugins_backup_20250825_070018/tools/remove_directory.py

@@ -1,55 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.plugins.tools.decorators import register_core_tool
-from janito.tools.tool_utils import pluralize, display_path
-from janito.i18n import tr
-import shutil
-import os
-import zipfile
-from janito.tools.path_utils import expand_path
-
-
-@register_core_tool
-class RemoveDirectory(ToolBase):
-    """
-    Remove a directory.
-
-    Args:
-        path (str): Path to the directory to remove.
-        recursive (bool, optional): If True, remove non-empty directories recursively (with backup). If False, only remove empty directories. Defaults to False.
-    Returns:
-        str: Status message indicating result. Example:
-            - "Directory removed: /path/to/dir"
-            - "Error removing directory: <error message>"
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "remove_directory"
-
-    def run(self, path: str, recursive: bool = False) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-        self.report_action(
-            tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
-            ReportAction.DELETE,
-        )
-
-        try:
-            if recursive:
-
-                shutil.rmtree(path)
-            else:
-                os.rmdir(path)
-            self.report_success(
-                tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
-                ReportAction.DELETE,
-            )
-            msg = tr("Directory removed: {disp_path}", disp_path=disp_path)
-
-            return msg
-        except Exception as e:
-            self.report_error(
-                tr(" ❌ Error removing directory: {error}", error=e),
-                ReportAction.DELETE,
-            )
-            return tr("Error removing directory: {error}", error=e)

janito/plugins_backup_20250825_070018/tools/remove_file.py

@@ -1,58 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from janito.plugins.tools.decorators import register_core_tool
-
-from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-@register_core_tool
-class RemoveFile(ToolBase):
-    """
-    Remove a file at the specified path.
-
-    Args:
-        path (str): Path to the file to remove.
-        backup (bool, optional): Deprecated. Backups are no longer created. Flag ignored.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "			 Successfully removed the file at ..."
-            - "			 Cannot remove file: ..."
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "remove_file"
-
-    def run(self, path: str, backup: bool = False) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-
-        # Report initial info about what is going to be removed
-        self.report_action(
-            tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
-            ReportAction.DELETE,
-        )
-        if not os.path.exists(path):
-            self.report_error(tr("❌ File does not exist."), ReportAction.DELETE)
-            return tr("❌ File does not exist.")
-        if not os.path.isfile(path):
-            self.report_error(tr("❌ Path is not a file."), ReportAction.DELETE)
-            return tr("❌ Path is not a file.")
-        try:
-
-            os.remove(path)
-            self.report_success(tr("✅ File removed"), ReportAction.DELETE)
-            msg = tr(
-                "✅ Successfully removed the file at '{disp_path}'.",
-                disp_path=disp_path,
-            )
-
-            return msg
-        except Exception as e:
-            self.report_error(
-                tr("❌ Error removing file: {error}", error=e), ReportAction.DELETE
-            )
-            return tr("❌ Error removing file: {error}", error=e)

janito/plugins_backup_20250825_070018/tools/run_bash_command.py

@@ -1,183 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.plugins.tools.decorators import register_core_tool
-from janito.i18n import tr
-import subprocess
-import tempfile
-import sys
-import os
-import threading
-
-
-@register_core_tool
-class RunBashCommand(ToolBase):
-    """
-    Execute a non-interactive command using the bash shell and capture live output.
-    This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).
-
-    Args:
-        command (str): The bash command to execute.
-        timeout (int): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
-        requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
-        silent (bool): If True, suppresses progress and status messages. Defaults to False.
-
-    Returns:
-        str: File paths and line counts for stdout and stderr.
-    """
-
-    permissions = ToolPermissions(execute=True)
-    tool_name = "run_bash_command"
-
-    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
-        for line in stream:
-            file_obj.write(line)
-            file_obj.flush()
-            report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
-            if count_func == "stdout":
-                counter["stdout"] += 1
-            else:
-                counter["stderr"] += 1
-
-    def run(
-        self,
-        command: str,
-        timeout: int = 60,
-        require_confirmation: bool = False,
-        requires_user_input: bool = False,
-        silent: bool = False,
-    ) -> str:
-        if not command.strip():
-            self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty command provided. Operation skipped.")
-        if not silent:
-            self.report_action(
-                tr("🖥️  Run bash command: {command} ...\n", command=command),
-                ReportAction.EXECUTE,
-            )
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        if requires_user_input and not silent:
-            self.report_warning(
-                tr(
-                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
-                ),
-                ReportAction.EXECUTE,
-            )
-            sys.stdout.flush()
-        try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+", prefix="run_bash_stdout_", delete=False, encoding="utf-8"
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+", prefix="run_bash_stderr_", delete=False, encoding="utf-8"
-                ) as stderr_file,
-            ):
-                env = os.environ.copy()
-                env["PYTHONIOENCODING"] = "utf-8"
-                env["LC_ALL"] = "C.UTF-8"
-                env["LANG"] = "C.UTF-8"
-                process = subprocess.Popen(
-                    ["bash", "-c", command],
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                    encoding="utf-8",
-                    bufsize=1,
-                    env=env,
-                )
-                counter = {"stdout": 0, "stderr": 0}
-                stdout_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stdout,
-                        stdout_file,
-                        self.report_stdout,
-                        "stdout",
-                        counter,
-                    ),
-                )
-                stderr_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stderr,
-                        stderr_file,
-                        self.report_stderr,
-                        "stderr",
-                        counter,
-                    ),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr(
-                            " ❌ Timed out after {timeout} seconds.",
-                            timeout=timeout,
-                        ),
-                        ReportAction.EXECUTE,
-                    )
-                    return tr(
-                        "Command timed out after {timeout} seconds.", timeout=timeout
-                    )
-                stdout_thread.join()
-                stderr_thread.join()
-                stdout_file.flush()
-                stderr_file.flush()
-                if not silent:
-                    self.report_success(
-                        tr(
-                            " ✅ return code {return_code}",
-                            return_code=return_code,
-                        ),
-                        ReportAction.EXECUTE,
-                    )
-                max_lines = 100
-                # Read back the output for summary
-                stdout_file.seek(0)
-                stderr_file.seek(0)
-                stdout_content = stdout_file.read()
-                stderr_content = stderr_file.read()
-                stdout_lines = counter["stdout"]
-                stderr_lines = counter["stderr"]
-                warning_msg = ""
-                if requires_user_input:
-                    warning_msg = tr(
-                        "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-                    )
-                if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = warning_msg + tr(
-                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
-                        return_code=return_code,
-                        stdout_content=stdout_content,
-                    )
-                    if stderr_content.strip():
-                        result += tr(
-                            "\n--- STDERR ---\n{stderr_content}",
-                            stderr_content=stderr_content,
-                        )
-                    return result
-                else:
-                    result = warning_msg + tr(
-                        "[LARGE OUTPUT]\nstdout_file: {stdout_file} (lines: {stdout_lines})\n",
-                        stdout_file=stdout_file.name,
-                        stdout_lines=stdout_lines,
-                    )
-                    if stderr_lines > 0:
-                        result += tr(
-                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
-                            stderr_file=stderr_file.name,
-                            stderr_lines=stderr_lines,
-                        )
-                    result += tr(
-                        "returncode: {return_code}\nUse the view_file tool to inspect the contents of these files when needed.",
-                        return_code=return_code,
-                    )
-                    return result
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            return tr("Error running command: {error}", error=e)