openhands 0.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

openhands/tools/str_replace_editor/exceptions.py

@@ -1,41 +0,0 @@
-class ToolError(Exception):
-    """Raised when a tool encounters an error."""
-
-    def __init__(self, message):
-        self.message = message
-        super().__init__(message)
-
-    def __str__(self):
-        return self.message
-
-
-class EditorToolParameterMissingError(ToolError):
-    """Raised when a required parameter is missing for a tool command."""
-
-    def __init__(self, command, parameter):
-        self.command = command
-        self.parameter = parameter
-        self.message = f"Parameter `{parameter}` is required for command: {command}."
-
-
-class EditorToolParameterInvalidError(ToolError):
-    """Raised when a parameter is invalid for a tool command."""
-
-    def __init__(self, parameter, value, hint=None):
-        self.parameter = parameter
-        self.value = value
-        self.message = (
-            f"Invalid `{parameter}` parameter: {value}. {hint}"
-            if hint
-            else f"Invalid `{parameter}` parameter: {value}."
-        )
-
-
-class FileValidationError(ToolError):
-    """Raised when a file fails validation checks (size, type, etc.)."""
-
-    def __init__(self, path: str, reason: str):
-        self.path = path
-        self.reason = reason
-        self.message = f"File validation failed for {path}: {reason}"
-        super().__init__(self.message)

openhands/tools/str_replace_editor/impl.py

@@ -1,66 +0,0 @@
-from openhands.sdk.tool import ToolExecutor
-from openhands.tools.str_replace_editor.definition import (
-    CommandLiteral,
-    StrReplaceEditorAction,
-    StrReplaceEditorObservation,
-)
-from openhands.tools.str_replace_editor.editor import FileEditor
-from openhands.tools.str_replace_editor.exceptions import ToolError
-
-
-# Module-global editor instance (lazily initialized in file_editor)
-_GLOBAL_EDITOR: FileEditor | None = None
-
-
-class FileEditorExecutor(ToolExecutor):
-    def __init__(self):
-        self.editor = FileEditor()
-
-    def __call__(self, action: StrReplaceEditorAction) -> StrReplaceEditorObservation:
-        result: StrReplaceEditorObservation | None = None
-        try:
-            result = self.editor(
-                command=action.command,
-                path=action.path,
-                file_text=action.file_text,
-                view_range=action.view_range,
-                old_str=action.old_str,
-                new_str=action.new_str,
-                insert_line=action.insert_line,
-            )
-        except ToolError as e:
-            result = StrReplaceEditorObservation(error=e.message)
-        assert result is not None, "file_editor should always return a result"
-        return result
-
-
-def file_editor(
-    command: CommandLiteral,
-    path: str,
-    file_text: str | None = None,
-    view_range: list[int] | None = None,
-    old_str: str | None = None,
-    new_str: str | None = None,
-    insert_line: int | None = None,
-) -> StrReplaceEditorObservation:
-    """A global FileEditor instance to be used by the tool."""
-
-    global _GLOBAL_EDITOR
-    if _GLOBAL_EDITOR is None:
-        _GLOBAL_EDITOR = FileEditor()
-
-    result: StrReplaceEditorObservation | None = None
-    try:
-        result = _GLOBAL_EDITOR(
-            command=command,
-            path=path,
-            file_text=file_text,
-            view_range=view_range,
-            old_str=old_str,
-            new_str=new_str,
-            insert_line=insert_line,
-        )
-    except ToolError as e:
-        result = StrReplaceEditorObservation(error=e.message)
-    assert result is not None, "file_editor should always return a result"
-    return result

openhands/tools/str_replace_editor/utils/config.py

@@ -1,2 +0,0 @@
-MAX_RESPONSE_LEN_CHAR: int = 16000
-SNIPPET_CONTEXT_WINDOW: int = 4

openhands/tools/str_replace_editor/utils/constants.py

@@ -1,9 +0,0 @@
-MAX_RESPONSE_LEN_CHAR: int = 16000
-
-CONTENT_TRUNCATED_NOTICE = "<response clipped><NOTE>Due to the max output limit, only part of the full response has been shown to you.</NOTE>"  # noqa: E501
-
-TEXT_FILE_CONTENT_TRUNCATED_NOTICE: str = "<response clipped><NOTE>Due to the max output limit, only part of this file has been shown to you. You should retry this tool after you have searched inside the file with `grep -n` in order to find the line numbers of what you are looking for.</NOTE>"  # noqa: E501
-
-BINARY_FILE_CONTENT_TRUNCATED_NOTICE: str = "<response clipped><NOTE>Due to the max output limit, only part of this file has been shown to you. Please use Python libraries to view the entire file or search for specific content within the file.</NOTE>"  # noqa: E501
-
-DIRECTORY_CONTENT_TRUNCATED_NOTICE: str = "<response clipped><NOTE>Due to the max output limit, only part of this directory has been shown to you. You should use `ls -la` instead to view large directories incrementally.</NOTE>"  # noqa: E501

openhands/tools/str_replace_editor/utils/encoding.py

@@ -1,135 +0,0 @@
-"""Encoding management for file operations."""
-
-import functools
-import inspect
-import os
-from pathlib import Path
-from typing import TYPE_CHECKING, Tuple
-
-import charset_normalizer
-from cachetools import LRUCache
-
-
-if TYPE_CHECKING:
-    from openhands.tools.str_replace_editor.impl import FileEditor
-
-
-class EncodingManager:
-    """Manages file encodings across multiple operations to ensure consistency."""
-
-    # Default maximum number of entries in the cache
-    DEFAULT_MAX_CACHE_SIZE = 1000  # ~= 300 KB
-
-    def __init__(self, max_cache_size=None):
-        # Cache detected encodings to avoid repeated detection on the same file
-        # Format: {path_str: (encoding, mtime)}
-        self._encoding_cache: LRUCache[str, Tuple[str, float]] = LRUCache(
-            maxsize=max_cache_size or self.DEFAULT_MAX_CACHE_SIZE
-        )
-        # Default fallback encoding
-        self.default_encoding = "utf-8"
-        # Confidence threshold for encoding detection
-        self.confidence_threshold = 0.9
-
-    def detect_encoding(self, path: Path) -> str:
-        """Detect the encoding of a file without handling caching logic.
-        Args:
-            path: Path to the file
-        Returns:
-            The detected encoding or default encoding if detection fails
-        """
-        # Handle non-existent files
-        if not path.exists():
-            return self.default_encoding
-
-        # Read a sample of the file to detect encoding
-        sample_size = min(os.path.getsize(path), 1024 * 1024)  # Max 1MB sample
-        with open(path, "rb") as f:
-            raw_data = f.read(sample_size)
-
-        # Use charset_normalizer instead of chardet
-        results = charset_normalizer.detect(raw_data)
-
-        # Get the best match if any exists
-        if (
-            results
-            and results["confidence"]
-            and results["confidence"] > self.confidence_threshold
-            and results["encoding"]
-        ):
-            encoding = results["encoding"]
-            # Always use utf-8 instead of ascii for text files to support
-            # non-ASCII characters. This ensures files initially containing only
-            # ASCII can later accept non-ASCII content
-            if encoding.lower() == "ascii":
-                encoding = self.default_encoding
-        else:
-            encoding = self.default_encoding
-
-        return encoding
-
-    def get_encoding(self, path: Path) -> str:
-        """Get encoding for a file, using cache or detecting if necessary.
-        Args:
-            path: Path to the file
-        Returns:
-            The encoding for the file
-        """
-        path_str = str(path)
-        # If file doesn't exist, return default encoding
-        if not path.exists():
-            return self.default_encoding
-
-        # Get current modification time
-        current_mtime = os.path.getmtime(path)
-
-        # Check cache for valid entry
-        if path_str in self._encoding_cache:
-            cached_encoding, cached_mtime = self._encoding_cache[path_str]
-            if cached_mtime == current_mtime:
-                return cached_encoding
-
-        # No valid cache entry, detect encoding
-        encoding = self.detect_encoding(path)
-
-        # Cache the result with current modification time
-        self._encoding_cache[path_str] = (encoding, current_mtime)
-        return encoding
-
-
-def with_encoding(method):
-    """Decorator to handle file encoding for file operations.
-    This decorator automatically detects and applies the correct encoding
-    for file operations, ensuring consistency between read and write operations.
-    Args:
-        method: The method to decorate
-    Returns:
-        The decorated method
-    """
-
-    @functools.wraps(method)
-    def wrapper(self: "FileEditor", path: Path, *args, **kwargs):
-        # Skip encoding handling for directories
-        if path.is_dir():
-            return method(self, path, *args, **kwargs)
-
-        # Check if the method accepts an encoding parameter
-        sig = inspect.signature(method)
-        accepts_encoding = "encoding" in sig.parameters
-
-        if accepts_encoding:
-            # For files that don't exist yet (like in 'create' command),
-            # use the default encoding
-            if not path.exists():
-                if "encoding" not in kwargs:
-                    kwargs["encoding"] = self._encoding_manager.default_encoding
-            else:
-                # Get encoding from the encoding manager for existing files
-                encoding = self._encoding_manager.get_encoding(path)
-                # Add encoding to kwargs if the method accepts it
-                if "encoding" not in kwargs:
-                    kwargs["encoding"] = encoding
-
-        return method(self, path, *args, **kwargs)
-
-    return wrapper

openhands/tools/str_replace_editor/utils/file_cache.py

@@ -1,154 +0,0 @@
-import hashlib
-import json
-import os
-import time
-from pathlib import Path
-from typing import Any, Optional
-
-from openhands.sdk.logger import get_logger
-
-
-logger = get_logger(__name__)
-
-
-class FileCache:
-    def __init__(self, directory: str, size_limit: Optional[int] = None):
-        self.directory = Path(directory)
-        self.directory.mkdir(parents=True, exist_ok=True)
-        self.size_limit = size_limit
-        self.current_size = 0
-        self._update_current_size()
-        logger.debug(
-            f"FileCache initialized with directory: {self.directory}, "
-            f"size_limit: {self.size_limit}, current_size: {self.current_size}"
-        )
-
-    def _get_file_path(self, key: str) -> Path:
-        hashed_key = hashlib.sha256(key.encode()).hexdigest()
-        return self.directory / f"{hashed_key}.json"
-
-    def _update_current_size(self):
-        self.current_size = sum(
-            f.stat().st_size for f in self.directory.glob("*.json") if f.is_file()
-        )
-        logger.debug(f"Current size updated: {self.current_size}")
-
-    def set(self, key: str, value: Any) -> None:
-        file_path = self._get_file_path(key)
-        content = json.dumps({"key": key, "value": value})
-        content_size = len(content.encode("utf-8"))
-        logger.debug(f"Setting key: {key}, content_size: {content_size}")
-
-        if self.size_limit is not None:
-            if file_path.exists():
-                old_size = file_path.stat().st_size
-                size_diff = content_size - old_size
-                logger.debug(
-                    f"Existing file: old_size: {old_size}, size_diff: {size_diff}"
-                )
-                if size_diff > 0:
-                    while (
-                        self.current_size + size_diff > self.size_limit
-                        and len(self) > 1
-                    ):
-                        logger.debug(
-                            f"Evicting oldest (existing file case): "
-                            f"current_size: {self.current_size}, "
-                            f"size_limit: {self.size_limit}"
-                        )
-                        self._evict_oldest(file_path)
-            else:
-                while (
-                    self.current_size + content_size > self.size_limit and len(self) > 1
-                ):
-                    logger.debug(
-                        f"Evicting oldest (new file case): "
-                        f"current_size: {self.current_size}, "
-                        f"size_limit: {self.size_limit}"
-                    )
-                    self._evict_oldest(file_path)
-
-        if file_path.exists():
-            self.current_size -= file_path.stat().st_size
-            logger.debug(
-                f"Existing file removed from current_size: {self.current_size}"
-            )
-
-        with open(file_path, "w") as f:
-            f.write(content)
-
-        self.current_size += content_size
-        logger.debug(f"File written, new current_size: {self.current_size}")
-        os.utime(
-            file_path, (time.time(), time.time())
-        )  # Update access and modification time
-
-    def _evict_oldest(self, exclude_path: Optional[Path] = None):
-        oldest_file = min(
-            (
-                f
-                for f in self.directory.glob("*.json")
-                if f.is_file() and f != exclude_path
-            ),
-            key=os.path.getmtime,
-        )
-        evicted_size = oldest_file.stat().st_size
-        self.current_size -= evicted_size
-        os.remove(oldest_file)
-        logger.debug(
-            f"Evicted file: {oldest_file}, size: {evicted_size}, "
-            f"new current_size: {self.current_size}"
-        )
-
-    def get(self, key: str, default: Any = None) -> Any:
-        file_path = self._get_file_path(key)
-        if not file_path.exists():
-            logger.debug(f"Get: Key not found: {key}")
-            return default
-        with open(file_path, "r") as f:
-            data = json.load(f)
-            os.utime(file_path, (time.time(), time.time()))  # Update access time
-            logger.debug(f"Get: Key found: {key}")
-            return data["value"]
-
-    def delete(self, key: str) -> None:
-        file_path = self._get_file_path(key)
-        if file_path.exists():
-            deleted_size = file_path.stat().st_size
-            self.current_size -= deleted_size
-            os.remove(file_path)
-            logger.debug(
-                f"Deleted key: {key}, size: {deleted_size}, "
-                f"new current_size: {self.current_size}"
-            )
-
-    def clear(self) -> None:
-        for item in self.directory.glob("*.json"):
-            if item.is_file():
-                os.remove(item)
-        self.current_size = 0
-        logger.debug("Cache cleared")
-
-    def __contains__(self, key: str) -> bool:
-        exists = self._get_file_path(key).exists()
-        logger.debug(f"Contains check: {key}, result: {exists}")
-        return exists
-
-    def __len__(self) -> int:
-        length = sum(1 for _ in self.directory.glob("*.json") if _.is_file())
-        logger.debug(f"Cache length: {length}")
-        return length
-
-    def __iter__(self):
-        for file in self.directory.glob("*.json"):
-            if file.is_file():
-                with open(file, "r") as f:
-                    data = json.load(f)
-                    logger.debug(f"Yielding key: {data['key']}")
-                    yield data["key"]
-
-    def __getitem__(self, key: str) -> Any:
-        return self.get(key)
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.set(key, value)

openhands/tools/str_replace_editor/utils/history.py

@@ -1,122 +0,0 @@
-"""History management for file edits with disk-based storage and memory constraints."""
-
-import logging
-import tempfile
-from pathlib import Path
-from typing import List, Optional
-
-from openhands.tools.str_replace_editor.utils.file_cache import FileCache
-
-
-class FileHistoryManager:
-    """Manages file edit history with disk-based storage and memory constraints."""
-
-    def __init__(
-        self, max_history_per_file: int = 5, history_dir: Optional[Path] = None
-    ):
-        """Initialize the history manager.
-
-        Args:
-            max_history_per_file: Maximum number of history entries to keep per
-                file (default: 5)
-            history_dir: Directory to store history files. If None, uses a temp
-                directory
-
-        Notes:
-            - Each file's history is limited to the last N entries to conserve
-              memory
-            - The file cache is limited to prevent excessive disk usage
-            - Older entries are automatically removed when limits are exceeded
-        """
-        self.max_history_per_file = max_history_per_file
-        if history_dir is None:
-            history_dir = Path(tempfile.mkdtemp(prefix="oh_editor_history_"))
-        self.cache = FileCache(str(history_dir))
-        self.logger = logging.getLogger(__name__)
-
-    def _get_metadata_key(self, file_path: Path) -> str:
-        return f"{file_path}.metadata"
-
-    def _get_history_key(self, file_path: Path, counter: int) -> str:
-        return f"{file_path}.{counter}"
-
-    def add_history(self, file_path: Path, content: str):
-        """Add a new history entry for a file."""
-        metadata_key = self._get_metadata_key(file_path)
-        metadata = self.cache.get(metadata_key, {"entries": [], "counter": 0})
-        counter = metadata["counter"]
-
-        # Add new entry
-        history_key = self._get_history_key(file_path, counter)
-        self.cache.set(history_key, content)
-
-        metadata["entries"].append(counter)
-        metadata["counter"] += 1
-
-        # Keep only last N entries
-        while len(metadata["entries"]) > self.max_history_per_file:
-            old_counter = metadata["entries"].pop(0)
-            old_history_key = self._get_history_key(file_path, old_counter)
-            self.cache.delete(old_history_key)
-
-        self.cache.set(metadata_key, metadata)
-
-    def pop_last_history(self, file_path: Path) -> Optional[str]:
-        """Pop and return the most recent history entry for a file."""
-        metadata_key = self._get_metadata_key(file_path)
-        metadata = self.cache.get(metadata_key, {"entries": [], "counter": 0})
-        entries = metadata["entries"]
-
-        if not entries:
-            return None
-
-        # Pop and remove the last entry
-        last_counter = entries.pop()
-        history_key = self._get_history_key(file_path, last_counter)
-        content = self.cache.get(history_key)
-
-        if content is None:
-            self.logger.warning(f"History entry not found for {file_path}")
-        else:
-            # Remove the entry from the cache
-            self.cache.delete(history_key)
-
-        # Update metadata
-        metadata["entries"] = entries
-        self.cache.set(metadata_key, metadata)
-
-        return content
-
-    def get_metadata(self, file_path: Path):
-        """Get metadata for a file (for testing purposes)."""
-        metadata_key = self._get_metadata_key(file_path)
-        metadata = self.cache.get(metadata_key, {"entries": [], "counter": 0})
-        return metadata  # Return the actual metadata, not a copy
-
-    def clear_history(self, file_path: Path):
-        """Clear history for a given file."""
-        metadata_key = self._get_metadata_key(file_path)
-        metadata = self.cache.get(metadata_key, {"entries": [], "counter": 0})
-
-        # Delete all history entries
-        for counter in metadata["entries"]:
-            history_key = self._get_history_key(file_path, counter)
-            self.cache.delete(history_key)
-
-        # Clear metadata
-        self.cache.set(metadata_key, {"entries": [], "counter": 0})
-
-    def get_all_history(self, file_path: Path) -> List[str]:
-        """Get all history entries for a file."""
-        metadata_key = self._get_metadata_key(file_path)
-        metadata = self.cache.get(metadata_key, {"entries": [], "counter": 0})
-        entries = metadata["entries"]
-
-        history = []
-        for counter in entries:
-            history_key = self._get_history_key(file_path, counter)
-            content = self.cache.get(history_key)
-            if content is not None:
-                history.append(content)
-
-        return history

openhands/tools/str_replace_editor/utils/shell.py

@@ -1,72 +0,0 @@
-import os
-import subprocess
-import time
-
-from openhands.sdk.utils.truncate import maybe_truncate
-from openhands.tools.str_replace_editor.utils.constants import (
-    CONTENT_TRUNCATED_NOTICE,
-    MAX_RESPONSE_LEN_CHAR,
-)
-
-
-def run_shell_cmd(
-    cmd: str,
-    timeout: float | None = 120.0,  # seconds
-    truncate_after: int | None = MAX_RESPONSE_LEN_CHAR,
-    truncate_notice: str = CONTENT_TRUNCATED_NOTICE,
-) -> tuple[int, str, str]:
-    """Run a shell command synchronously with a timeout.
-
-    Args:
-        cmd: The shell command to run.
-        timeout: The maximum time to wait for the command to complete.
-        truncate_after: The maximum number of characters to return for stdout
-            and stderr.
-
-    Returns:
-        A tuple containing the return code, stdout, and stderr.
-    """
-
-    start_time = time.time()
-
-    process: subprocess.Popen | None = None
-    try:
-        process = subprocess.Popen(
-            cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-        )
-
-        stdout, stderr = process.communicate(timeout=timeout)
-
-        return (
-            process.returncode or 0,
-            maybe_truncate(
-                stdout, truncate_after=truncate_after, truncate_notice=truncate_notice
-            ),
-            maybe_truncate(
-                stderr,
-                truncate_after=truncate_after,
-                truncate_notice=CONTENT_TRUNCATED_NOTICE,
-            ),  # Use generic notice for stderr
-        )
-    except subprocess.TimeoutExpired:
-        if process:
-            process.kill()
-        elapsed_time = time.time() - start_time
-        raise TimeoutError(
-            f"Command '{cmd}' timed out after {elapsed_time:.2f} seconds"
-        )
-
-
-def check_tool_installed(tool_name: str) -> bool:
-    """Check if a tool is installed."""
-    try:
-        subprocess.run(
-            [tool_name, "--version"],
-            check=True,
-            cwd=os.getcwd(),
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False

openhands/tools/task_tracker/__init__.py

@@ -1,16 +0,0 @@
-from .definition import (
-    TaskTrackerAction,
-    TaskTrackerExecutor,
-    TaskTrackerObservation,
-    TaskTrackerTool,
-    task_tracker_tool,
-)
-
-
-__all__ = [
-    "TaskTrackerAction",
-    "TaskTrackerExecutor",
-    "TaskTrackerObservation",
-    "TaskTrackerTool",
-    "task_tracker_tool",
-]