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

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}"

janito/plugins_backup_20250825_070018/discovery.py

@@ -1,289 +0,0 @@
-"""
-Plugin discovery utilities.
-
-Plugins can be provided in several formats:
-
-1. Single Python file: A .py file containing a Plugin class
-   Example: plugins/my_plugin.py
-
-2. Python package directory: A directory with __init__.py or plugin.py
-   Example: plugins/my_plugin/__init__.py
-   Example: plugins/my_plugin/plugin.py
-
-3. Installed Python package: An installed package with a Plugin class
-   Example: pip install janito-plugin-example
-
-4. ZIP file: A .zip file containing a Python package structure
-   Example: plugins/my_plugin.zip (containing package structure)
-
-The plugin discovery system searches these locations in order:
-- Current working directory/plugins/
-- ~/.janito/plugins/
-- Python installation share/janito/plugins/
-- Any additional paths specified via configuration
-"""
-
-import os
-import sys
-import importlib
-import importlib.util
-from pathlib import Path
-from typing import Optional, List
-import logging
-
-from janito.plugin_system.base import Plugin
-from .builtin import load_builtin_plugin, BuiltinPluginRegistry
-from janito.plugin_system.core_loader import load_core_plugin
-
-logger = logging.getLogger(__name__)
-
-
-def discover_plugins(
-    plugin_name: str, search_paths: List[Path] = None
-) -> Optional[Plugin]:
-    """
-    Discover and load a plugin by name.
-
-    Supports multiple plugin formats:
-    - Single .py files
-    - Python package directories
-    - Package-based plugins (e.g., core.filemanager)
-    - Installed Python packages
-    - ZIP files containing packages
-
-    Args:
-        plugin_name: Name of the plugin to discover
-        search_paths: List of directories to search for plugins
-
-    Returns:
-        Plugin instance if found, None otherwise
-    """
-    if search_paths is None:
-        search_paths = []
-
-    # Add default search paths
-    default_paths = [
-        Path.cwd() / "plugins",
-        Path.home() / ".janito" / "plugins",
-        Path(sys.prefix) / "share" / "janito" / "plugins",
-    ]
-
-    all_paths = search_paths + default_paths
-
-    # Handle package-based plugins (e.g., core.filemanager)
-    if "." in plugin_name:
-        parts = plugin_name.split(".")
-        if len(parts) == 2:
-            package_name, submodule_name = parts
-
-            # Handle core plugins with dedicated loader
-            if plugin_name.startswith(("core.", "dev.", "ui.", "web.")):
-                plugin = load_core_plugin(plugin_name)
-                if plugin:
-                    return plugin
-
-            for base_path in all_paths:
-                package_path = base_path / package_name / submodule_name / "__init__.py"
-                if package_path.exists():
-                    return _load_plugin_from_file(package_path, plugin_name=plugin_name)
-
-                plugin_path = base_path / package_name / submodule_name / "plugin.py"
-                if plugin_path.exists():
-                    return _load_plugin_from_file(plugin_path, plugin_name=plugin_name)
-
-    # Try to find plugin in search paths
-    for base_path in all_paths:
-        plugin_path = base_path / plugin_name
-        if plugin_path.exists():
-            return _load_plugin_from_directory(plugin_path)
-
-        # Try as Python module
-        module_path = base_path / f"{plugin_name}.py"
-        if module_path.exists():
-            return _load_plugin_from_file(module_path)
-
-    # Check for builtin plugins
-    builtin_plugin = load_builtin_plugin(plugin_name)
-    if builtin_plugin:
-        return builtin_plugin
-
-    # Try importing as installed package
-    try:
-        return _load_plugin_from_package(plugin_name)
-    except ImportError:
-        pass
-
-    return None
-
-
-def _load_plugin_from_directory(plugin_path: Path) -> Optional[Plugin]:
-    """Load a plugin from a directory."""
-    try:
-        # Look for __init__.py or plugin.py
-        init_file = plugin_path / "__init__.py"
-        plugin_file = plugin_path / "plugin.py"
-
-        if init_file.exists():
-            return _load_plugin_from_file(init_file, plugin_name=plugin_path.name)
-        elif plugin_file.exists():
-            return _load_plugin_from_file(plugin_file, plugin_name=plugin_path.name)
-
-    except Exception as e:
-        logger.error(f"Failed to load plugin from directory {plugin_path}: {e}")
-
-    return None
-
-
-def _load_plugin_from_file(
-    file_path: Path, plugin_name: str = None
-) -> Optional[Plugin]:
-    """Load a plugin from a Python file."""
-    try:
-        if plugin_name is None:
-            plugin_name = file_path.stem
-
-        spec = importlib.util.spec_from_file_location(plugin_name, file_path)
-        if spec is None or spec.loader is None:
-            return None
-
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-
-        # Look for Plugin class
-        for attr_name in dir(module):
-            attr = getattr(module, attr_name)
-            if isinstance(attr, type) and issubclass(attr, Plugin) and attr != Plugin:
-                return attr()
-
-        # Check for package-based plugin with __plugin_name__ metadata
-        if hasattr(module, "__plugin_name__"):
-            from janito.plugin_system.base import PluginMetadata
-
-            # Create a dynamic plugin class
-            class PackagePlugin(Plugin):
-                def __init__(self):
-                    super().__init__()
-                    self._module = module
-
-                def get_metadata(self) -> PluginMetadata:
-                    return PluginMetadata(
-                        name=getattr(module, "__plugin_name__", plugin_name),
-                        version=getattr(module, "__plugin_version__", "1.0.0"),
-                        description=getattr(
-                            module,
-                            "__plugin_description__",
-                            f"Package plugin: {plugin_name}",
-                        ),
-                        author=getattr(module, "__plugin_author__", "Unknown"),
-                        license=getattr(module, "__plugin_license__", "MIT"),
-                    )
-
-                def get_tools(self):
-                    return getattr(module, "__plugin_tools__", [])
-
-                def initialize(self):
-                    if hasattr(module, "initialize"):
-                        module.initialize()
-
-                def cleanup(self):
-                    if hasattr(module, "cleanup"):
-                        module.cleanup()
-
-            return PackagePlugin()
-
-    except Exception as e:
-        logger.error(f"Failed to load plugin from file {file_path}: {e}")
-
-    return None
-
-
-def _load_plugin_from_package(package_name: str) -> Optional[Plugin]:
-    """Load a plugin from an installed package."""
-    try:
-        module = importlib.import_module(package_name)
-
-        # Look for Plugin class
-        for attr_name in dir(module):
-            attr = getattr(module, attr_name)
-            if isinstance(attr, type) and issubclass(attr, Plugin) and attr != Plugin:
-                return attr()
-
-    except ImportError as e:
-        logger.debug(f"Could not import package {package_name}: {e}")
-
-    return None
-
-
-def list_available_plugins(search_paths: List[Path] = None) -> List[str]:
-    """
-    List all available plugins in search paths.
-
-    Scans for plugins in multiple formats:
-    - .py files (excluding __init__.py)
-    - Directories with __init__.py or plugin.py
-    - Package directories with plugin metadata (__plugin_name__)
-    - Any valid plugin structure in search paths
-
-    Args:
-        search_paths: List of directories to search for plugins
-
-    Returns:
-        List of plugin names found
-    """
-    if search_paths is None:
-        search_paths = []
-
-    # Add default search paths
-    default_paths = [
-        Path.cwd() / "plugins",
-        Path.home() / ".janito" / "plugins",
-        Path(sys.prefix) / "share" / "janito" / "plugins",
-    ]
-
-    all_paths = search_paths + default_paths
-    plugins = []
-
-    for base_path in all_paths:
-        if not base_path.exists():
-            continue
-
-        # Look for directories with __init__.py or plugin.py
-        for item in base_path.iterdir():
-            if item.is_dir():
-                # Check for package-based plugins (subdirectories with __init__.py)
-                if (item / "__init__.py").exists():
-                    # Check subdirectories for plugin metadata
-                    for subitem in item.iterdir():
-                        if subitem.is_dir() and (subitem / "__init__.py").exists():
-                            try:
-                                import importlib.util
-
-                                spec = importlib.util.spec_from_file_location(
-                                    f"{item.name}.{subitem.name}",
-                                    subitem / "__init__.py",
-                                )
-                                if spec and spec.loader:
-                                    module = importlib.util.module_from_spec(spec)
-                                    spec.loader.exec_module(module)
-
-                                    # Check for plugin metadata
-                                    if hasattr(module, "__plugin_name__"):
-                                        plugins.append(
-                                            getattr(module, "__plugin_name__")
-                                        )
-                            except Exception:
-                                pass
-
-                # Also check for plugin.py files
-                plugin_file = item / "plugin.py"
-                if plugin_file.exists():
-                    plugins.append(item.name)
-
-            elif item.suffix == ".py" and item.stem != "__init__":
-                plugins.append(item.stem)
-
-    # Add builtin plugins
-    builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
-    plugins.extend(builtin_plugins)
-
-    return sorted(set(plugins))

janito/plugins_backup_20250825_070018/example_plugin.py

@@ -1,108 +0,0 @@
-"""
-Example plugin demonstrating the plugin system.
-"""
-
-from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from typing import Dict, Any
-
-
-class HelloWorldTool(ToolBase):
-    """A simple tool that says hello."""
-
-    tool_name = "hello_world"
-    permissions = ToolPermissions(read=True, write=False, execute=True)
-
-    def run(self, name: str = "World") -> str:
-        """
-        Say hello to someone.
-
-        Args:
-            name: Name of the person to greet
-
-        Returns:
-            Greeting message
-        """
-        self.report_action(f"Saying hello to {name}", "greet")
-        return f"Hello, {name}!"
-
-
-class CalculatorTool(ToolBase):
-    """A simple calculator tool."""
-
-    tool_name = "calculator"
-    permissions = ToolPermissions(read=True, write=False, execute=True)
-
-    def run(self, operation: str, a: float, b: float) -> str:
-        """
-        Perform basic calculations.
-
-        Args:
-            operation: Operation to perform (add, subtract, multiply, divide)
-            a: First number
-            b: Second number
-
-        Returns:
-            Result as string
-        """
-        self.report_action(f"Calculating {a} {operation} {b}", "calculate")
-
-        if operation == "add":
-            result = a + b
-        elif operation == "subtract":
-            result = a - b
-        elif operation == "multiply":
-            result = a * b
-        elif operation == "divide":
-            if b == 0:
-                return "Error: Division by zero"
-            result = a / b
-        else:
-            return f"Error: Unknown operation '{operation}'"
-
-        return str(result)
-
-
-class ExamplePlugin(Plugin):
-    """Example plugin providing basic tools."""
-
-    def get_metadata(self) -> PluginMetadata:
-        return PluginMetadata(
-            name="example",
-            version="1.0.0",
-            description="Example plugin with basic tools",
-            author="Janito Team",
-            license="MIT",
-            homepage="https://github.com/janito/example-plugin",
-        )
-
-    def get_tools(self):
-        return [HelloWorldTool, CalculatorTool]
-
-    def initialize(self):
-        print("Example plugin initialized!")
-
-    def cleanup(self):
-        print("Example plugin cleaned up!")
-
-    def get_config_schema(self) -> Dict[str, Any]:
-        """Return JSON schema for plugin configuration."""
-        return {
-            "type": "object",
-            "properties": {
-                "greeting_prefix": {
-                    "type": "string",
-                    "description": "Custom greeting prefix for hello_world tool",
-                    "default": "Hello",
-                },
-                "max_calculation": {
-                    "type": "number",
-                    "description": "Maximum allowed calculation result",
-                    "default": 1000000,
-                },
-            },
-        }
-
-
-# This makes the plugin discoverable
-PLUGIN_CLASS = ExamplePlugin