janito 3.6.1__py3-none-any.whl → 3.8.0__py3-none-any.whl

janito/plugins/tools/core/open_html_in_browser.py

@@ -1,51 +0,0 @@
-import os
-import webbrowser
-from .decorators import register_core_tool
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_core_tool
-class OpenHtmlInBrowser(ToolBase):
-    """
-    Open the supplied HTML file in the default web browser.
-
-    Args:
-        path (str): Path to the HTML file to open.
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "open_html_in_browser"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str) -> str:
-        if not path.strip():
-            self.report_warning(tr("ℹ️ Empty file path provided."))
-            return tr("Warning: Empty file path provided. Operation skipped.")
-        if not os.path.isfile(path):
-            self.report_error(tr("❗ File does not exist: {path}", path=path))
-            return tr("Warning: File does not exist: {path}", path=path)
-        if not path.lower().endswith((".html", ".htm")):
-            self.report_warning(tr("⚠️ Not an HTML file: {path}", path=path))
-            return tr("Warning: Not an HTML file: {path}", path=path)
-        url = "file://" + os.path.abspath(path)
-        self.report_action(
-            tr("📖 Opening HTML file in browser: {path}", path=path), ReportAction.READ
-        )
-        try:
-            webbrowser.open(url)
-        except Exception as err:
-            self.report_error(
-                tr("❗ Error opening HTML file: {path}: {err}", path=path, err=str(err))
-            )
-            return tr(
-                "Warning: Error opening HTML file: {path}: {err}",
-                path=path,
-                err=str(err),
-            )
-        self.report_success(tr("✅ HTML file opened in browser: {path}", path=path))
-        return tr("HTML file opened in browser: {path}", path=path)

janito/plugins/tools/core/open_url.py

@@ -1,37 +0,0 @@
-import webbrowser
-from .decorators import register_core_tool
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_core_tool
-class OpenUrl(ToolBase):
-    """
-    Open the supplied URL or local file in the default web browser.
-
-    Args:
-        url (str): The URL or local file path (as a file:// URL) to open. Supports both web URLs (http, https) and local files (file://).
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "open_url"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="url")
-    def run(self, url: str) -> str:
-        if not url.strip():
-            self.report_warning(tr("ℹ️ Empty URL provided."))
-            return tr("Warning: Empty URL provided. Operation skipped.")
-        self.report_action(tr("🌐 Opening URL '{url}' ...", url=url), ReportAction.READ)
-        try:
-            webbrowser.open(url)
-        except Exception as err:
-            self.report_error(
-                tr("❗ Error opening URL: {url}: {err}", url=url, err=str(err))
-            )
-            return tr("Warning: Error opening URL: {url}: {err}", url=url, err=str(err))
-        self.report_success(tr("✅ URL opened in browser: {url}", url=url))
-        return tr("URL opened in browser: {url}", url=url)

janito/plugins/tools/core/read_chart.py

@@ -1,259 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from .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/tools/core/read_files.py

@@ -1,58 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from .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/tools/core/remove_directory.py

@@ -1,55 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from .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/tools/core/remove_file.py

@@ -1,58 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from .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/tools/core/search_text/__init__.py

@@ -1,7 +0,0 @@
-"""
-Text search tools for janito.
-"""
-
-from .core import SearchText
-
-__all__ = ["SearchText"]