quantalogic 0.2.0__py3-none-any.whl

quantalogic/utils/git_ls.py

@@ -0,0 +1,121 @@
+import os
+from pathlib import Path
+from typing import Dict, List
+
+from pathspec import PathSpec
+from pathspec.patterns import GitWildMatchPattern
+
+
+def git_ls(
+    directory_path: str, recursive: bool = False, max_depth: int = 10, start_line: int = 1, end_line: int = 500
+) -> str:
+    """List files respecting .gitignore rules with formatted output.
+
+    Args:
+        directory_path: Path to directory to list
+        recursive: Whether to list recursively ("true"/"false")
+        max_depth: Maximum recursion depth
+        start_line: Start line for pagination
+        end_line: End line for pagination
+
+    Returns:
+        Formatted tree structure with file info
+    """
+    # Convert inputs
+    recursive = recursive if isinstance(recursive, bool) else recursive.lower() == "true"
+    max_depth = int(max_depth)
+    start_line = int(start_line)
+    end_line = int(end_line)
+
+    # Expand paths and get absolute path
+    path = Path(os.path.expanduser(directory_path)).absolute()
+
+    # Load .gitignore patterns
+    ignore_spec = load_gitignore_spec(path)
+
+    # Generate file tree
+    tree = generate_file_tree(path, ignore_spec, recursive=recursive, max_depth=max_depth)
+
+    # Format and paginate output
+    return format_tree(tree, start_line, end_line)
+
+
+def load_gitignore_spec(path: Path) -> PathSpec:
+    """Load .gitignore patterns from directory and all parent directories."""
+    ignore_patterns = []
+    current = path
+
+    # Traverse up the directory tree
+    while current != current.parent:  # Stop at root
+        gitignore_path = current / ".gitignore"
+        if gitignore_path.exists():
+            with open(gitignore_path) as f:
+                # Prepend parent patterns to maintain precedence
+                ignore_patterns = f.readlines() + ignore_patterns
+        current = current.parent
+
+    return PathSpec.from_lines(GitWildMatchPattern, ignore_patterns)
+
+
+def generate_file_tree(
+    path: Path, ignore_spec: PathSpec, recursive: bool = False, max_depth: int = 1, current_depth: int = 0
+) -> Dict:
+    """Generate file tree structure."""
+    if current_depth > max_depth:
+        return {}
+
+    if ignore_spec.match_file(path) or path.name == ".git":
+        return {}
+
+    if path.is_file():
+        return {"name": path.name, "type": "file", "size": f"{path.stat().st_size} bytes"}
+
+    tree = {"name": path.name, "type": "directory", "children": []}
+
+    # Always list direct children, but only recursively list if recursive is True
+    children = sorted(path.iterdir(), key=lambda x: x.name.lower())
+    for child in children:
+        if not ignore_spec.match_file(child):
+            if child.is_file():
+                child_tree = generate_file_tree(child, ignore_spec, recursive, max_depth, current_depth)
+                tree["children"].append(child_tree)
+            elif child.is_dir():
+                # Always include directories
+                child_tree = generate_file_tree(child, ignore_spec, recursive, max_depth, current_depth + 1)
+                if recursive:
+                    if child_tree:
+                        tree["children"].append(child_tree)
+                else:
+                    tree["children"].append({"name": child.name, "type": "directory", "children": []})
+
+    return tree
+
+
+def format_tree(tree: Dict, start: int, end: int) -> str:
+    """Format tree structure into string output with line information."""
+    lines = []
+    _format_tree_recursive(tree, lines, 0)
+    total_lines = len(lines)
+    is_last_block = end >= total_lines
+    output = "\n".join(lines[start - 1 : end])
+
+    header = f"==== Lines: {start}-{end} of {total_lines} ===="
+    if is_last_block:
+        header = f"==== Lines: {start}-{total_lines} of {total_lines} ===="
+        header += f" [LAST BLOCK] (total_lines: {total_lines})"
+    return f"{header}\n{output}\n==== End of Block ===="
+
+
+def _format_tree_recursive(node: Dict, lines: List[str], depth: int):
+    """Recursively format tree nodes."""
+    indent = "  " * depth
+    if node["type"] == "file":
+        lines.append(f"{indent}📄 {node['name']} ({node['size']})")
+    else:
+        lines.append(f"{indent}📁 {node['name']}/")
+        for child in node["children"]:
+            _format_tree_recursive(child, lines, depth + 1)
+
+
+if __name__ == "__main__":
+    print(git_ls("./", recursive=True, max_depth=30, start_line=1, end_line=500))

quantalogic/utils/read_file.py

@@ -0,0 +1,54 @@
+"""Reads the content of a file and returns it as a string."""
+
+import os
+
+
+def read_file(file_path: str, max_size: int = 10 * 1024 * 1024) -> str:
+    """Reads the content of a file and returns it as a string.
+
+    This function performs the following steps:
+    1. Expands the tilde (~) in the file path to the user's home directory.
+    2. Converts a relative path to an absolute path.
+    3. Checks the file size before reading to ensure it is not too large.
+    4. Reads the file content and returns it as a string.
+    5. Handles common file operation errors such as FileNotFoundError, PermissionError, and OSError.
+
+    Parameters:
+    file_path (str): The path to the file to be read.
+
+    Returns:
+    str: The content of the file as a string.
+
+    Raises:
+    FileNotFoundError: If the file does not exist.
+    PermissionError: If the file cannot be read due to permission issues.
+    OSError: If the file size is too large or other OS-related errors occur.
+    """
+    try:
+        # Expand tilde to user's home directory
+        expanded_path = os.path.expanduser(file_path)
+
+        # Convert relative path to absolute path
+        absolute_path = os.path.abspath(expanded_path)
+
+        # Check if the file exists
+        if not os.path.exists(absolute_path):
+            raise FileNotFoundError(f"The file '{absolute_path}' does not exist.")
+
+        # Check file size before reading
+        file_size = os.path.getsize(absolute_path)
+        if file_size > max_size:
+            raise OSError(f"File size ({file_size} bytes) exceeds the maximum allowed size ({max_size} bytes).")
+
+        # Read the file content
+        with open(absolute_path, encoding="utf-8") as file:
+            content = file.read()
+
+        return content
+
+    except FileNotFoundError:
+        raise FileNotFoundError(f"The file '{absolute_path}' does not exist.")
+    except PermissionError:
+        raise PermissionError(f"Permission denied: Unable to read the file '{absolute_path}'.")
+    except OSError as e:
+        raise OSError(f"An error occurred while reading the file: {e}")

quantalogic/utils/read_http_text_content.py

@@ -0,0 +1,101 @@
+"""Utility function to read text content from a given URL and return it as a string."""
+
+import logging
+from time import sleep
+
+import requests
+from requests.exceptions import ConnectionError, HTTPError, RequestException
+
+# Configure logging
+logging.basicConfig(level=logging.ERROR, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def read_http_text_content(
+    url: str, timeout: int = 10, retries: int = 3, delay: int = 2
+) -> tuple[str | None, str | None]:
+    """Fetches the content from the given URL and returns it as a string.
+
+    Args:
+        url (str): The URL from which to fetch the content.
+        timeout (int): Timeout in seconds for the HTTP request. Default is 10.
+        retries (int): Number of retries in case of failure. Default is 3.
+        delay (int): Delay in seconds between retries. Default is 2.
+
+    Returns:
+        tuple[str | None, str | None]: A tuple containing the content as a string and an error message.
+                                       If successful, the error message is None.
+                                       If failed, the content is None and the error message is provided.
+
+    Examples:
+        >>> content, error = read_http_text_content("https://example.com/data.txt")
+        >>> if error:
+        ...     print(f"Error: {error}")
+        ... else:
+        ...     print(content)
+
+        >>> content, error = read_http_file("https://example.com/binary.data")
+        >>> if error:
+        ...     print(f"Error: {error}")  # Output: Error: Expected text-based content, but received binary content with Content-Type: application/octet-stream
+    """
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Accept": "text/plain, application/json, application/xml, text/csv, text/html, application/javascript, application/x-yaml, application/x-www-form-urlencoded, application/octet-stream",
+    }
+
+    for attempt in range(retries):
+        try:
+            logger.info(f"Attempt {attempt + 1} of {retries} to fetch {url}")
+            response = requests.get(url, headers=headers, timeout=timeout)
+            response.raise_for_status()  # Raise an HTTPError for bad responses (4xx and 5xx)
+
+            # Check if the content type is text-based
+            content_type = response.headers.get("Content-Type", "").lower()
+            text_based_types = [
+                "text/",
+                "application/json",
+                "application/xml",
+                "text/csv",
+                "text/html",
+                "application/javascript",
+                "application/x-yaml",
+                "application/x-www-form-urlencoded",
+            ]
+            if not any(content_type.startswith(t) for t in text_based_types):
+                error_msg = (
+                    f"Expected text-based content, but received binary content with Content-Type: {content_type}"
+                )
+                logger.error(error_msg)
+                return None, error_msg
+
+            return response.text, None
+        except HTTPError as http_err:
+            status_code = http_err.response.status_code if http_err.response else "unknown"
+            error_msg = f"HTTP error occurred (status code: {status_code}): {http_err}"
+            logger.error(error_msg)
+            if status_code in [404, 403, 401]:  # Don't retry for these status codes
+                break
+        except ConnectionError as conn_err:
+            error_msg = f"Connection error occurred (URL: {url}): {conn_err}"
+            logger.error(error_msg)
+        except requests.Timeout as timeout_err:
+            error_msg = f"Request timed out after {timeout} seconds: {timeout_err}"
+            logger.error(error_msg)
+        except RequestException as req_err:
+            error_msg = f"An unexpected error occurred (URL: {url}): {req_err}"
+            logger.error(error_msg)
+
+        if attempt < retries - 1:
+            sleep_duration = delay * (2**attempt)  # Exponential backoff
+            logger.info(f"Retrying in {sleep_duration} seconds...")
+            sleep(sleep_duration)
+
+    return None, error_msg
+
+
+if __name__ == "__main__":
+    content, error = read_http_text_content("https://www.quantalogic.app")
+    if error:
+        print(f"Error: {error}")
+    else:
+        print(content)

quantalogic/xml_parser.py

@@ -0,0 +1,242 @@
+"""XML parsing utilities for extracting and processing XML-like elements.
+
+This module provides tools for parsing and extracting XML-like elements from text,
+with support for handling malformed XML and CDATA sections.
+"""
+
+import html
+import re
+from collections import defaultdict
+from typing import Self
+
+from loguru import logger
+from pydantic import BaseModel, Field, model_validator
+
+
+class XMLElement(BaseModel):
+    """Represents a parsed XML element with its structural and content details.
+
+    This model captures the essential information of an XML element,
+    including its name, content, raw representation, and positional
+    information within the original XML document.
+
+    Attributes:
+        name: The name of the XML element (tag name).
+        content: The textual content of the XML element.
+        raw: The complete raw string representation of the XML element.
+        start_pos: Starting character position in the original document.
+        end_pos: Ending character position in the original document.
+        cdata_sections: List of CDATA sections within the element.
+    """
+
+    name: str = Field(..., description="The name of the XML element (tag name)")
+    content: str = Field(..., description="The textual content of the XML element")
+    raw: str = Field(..., description="The complete raw string representation")
+    start_pos: int = Field(..., description="Starting character position", ge=0)
+    end_pos: int = Field(..., description="Ending character position", gt=0)
+    cdata_sections: list[str] = Field(default_factory=list, description="List of CDATA sections within the element")
+
+    @model_validator(mode="after")
+    def validate_positions(self) -> Self:
+        """Validate that end_pos is greater than start_pos."""
+        if self.end_pos <= self.start_pos:
+            raise ValueError("end_pos must be greater than start_pos")
+        return self
+
+
+class ToleranceXMLParser:
+    """A flexible XML-like parser for malformed and non-standard XML elements.
+
+    This parser extracts XML-like elements from text, supporting various
+    edge cases such as incomplete tags and CDATA sections.
+    """
+
+    def __init__(self: Self) -> None:
+        """Initialize the parser with regex patterns for matching XML-like elements."""
+        # Pattern for matching individual XML elements, including malformed tags
+        # Modified to be more lenient with content and preserve exact formatting
+        self.element_pattern = re.compile(r"<([^/>]+?)>(.*?)(?:</\1>|<\1>)", re.DOTALL)
+        # Pattern for matching CDATA sections
+        self.cdata_pattern = re.compile(r"<!\[CDATA\[(.*?)]]>", re.DOTALL)
+        logger.debug("Initialized ToleranceXMLParser with regex patterns")
+
+    def _extract_and_remove_cdata(self: Self, content: str, preserve_cdata: bool = False) -> tuple[str, list[str]]:
+        """Extract CDATA sections from content.
+
+        Args:
+            content: Input text to extract CDATA sections from.
+            preserve_cdata: If True, preserve CDATA content in place.
+                          If False, remove CDATA sections and return them separately.
+
+        Returns:
+            A tuple containing:
+                - The original content with CDATA sections handled
+                - List of extracted CDATA contents
+        """
+        cdata_sections: list[str] = []
+
+        def replace_cdata(match: re.Match[str]) -> str:
+            cdata_content = match.group(1)
+            cdata_sections.append(cdata_content)
+            return cdata_content if preserve_cdata else match.group(0)
+
+        # Extract CDATA sections but keep the original content intact
+        cleaned_content = self.cdata_pattern.sub(replace_cdata, content)
+        return cleaned_content, cdata_sections
+
+    def _clean_content(self: Self, content: str) -> str:
+        """Clean XML content while preserving exact original formatting.
+
+        Args:
+            content: Raw XML content to clean.
+
+        Returns:
+            Content with unescaped HTML entities, preserving all original formatting.
+        """
+        # Only unescape HTML entities, preserve everything else exactly as is
+        return html.unescape(content)
+
+    def _map_element_name(self: Self, name: str) -> str:
+        """Map element names to their canonical form.
+
+        Args:
+            name: Raw element name from XML.
+
+        Returns:
+            Canonical element name.
+        """
+        # Map common element name variations
+        name_map = {"o": "output", "i": "input", "opt": "optional"}
+        return name_map.get(name.strip(), name.strip())
+
+    def _extract_element_content(self: Self, text: str, preserve_cdata: bool = False) -> dict[str, str]:
+        """Extract content from nested XML elements.
+
+        Args:
+            text: Input text containing XML elements.
+            preserve_cdata: If True, preserve CDATA content in place.
+
+        Returns:
+            Dictionary mapping element names to their content values.
+        """
+        elements: dict[str, str] = defaultdict(str)
+
+        # Process each match
+        for match in self.element_pattern.finditer(text):
+            name = match.group(1)
+            content = match.group(2) or ""
+
+            # Map element name to canonical form
+            name = self._map_element_name(name)
+
+            # Extract and handle CDATA sections
+            content, cdata_sections = self._extract_and_remove_cdata(content, preserve_cdata)
+
+            # Clean and normalize content
+            content = self._clean_content(content)
+
+            # If the content is empty but we have CDATA sections and we're
+            # not preserving them
+            if not content.strip() and cdata_sections and not preserve_cdata:
+                content = cdata_sections[0]
+
+            # Store the element content
+            elements[name] = content
+
+            # Extract nested elements from the content
+            nested_elements = self._extract_element_content(content, preserve_cdata)
+            elements.update(nested_elements)
+
+        return dict(elements)  # Convert defaultdict to regular dict
+
+    def extract_elements(
+        self: Self,
+        text: str,
+        element_names: list[str] | None = None,
+        preserve_cdata: bool = False,
+    ) -> dict[str, str]:
+        """Extract XML-like elements from text, grouped by element names.
+
+        Args:
+            text: Input text containing XML-like elements.
+            element_names: Optional list of element names to extract.
+                If None, extracts all elements.
+            preserve_cdata: If True, preserve CDATA content in place.
+                          If False, remove CDATA sections.
+
+        Returns:
+            Dictionary mapping element names to their content values.
+            For elements with multiple instances, only the last value is kept.
+
+        Raises:
+            ValueError: If the input text is invalid or contains malformed XML.
+        """
+        try:
+            if not text or not isinstance(text, str):
+                raise ValueError("Input text must be a non-empty string")
+
+            logger.debug(f"Extracting elements: {element_names or 'all'}")
+
+            # Extract all elements and their content
+            elements = self._extract_element_content(text, preserve_cdata)
+
+            # Filter elements if specific names were requested
+            if element_names is not None:
+                elements = {name: content for name, content in elements.items() if name in element_names}
+
+            logger.debug(f"Successfully extracted {len(elements)} elements")
+            return elements
+
+        except Exception as e:
+            error_msg = f"Error extracting XML elements: {str(e)}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+    def find_elements(self: Self, text: str, element_name: str) -> list[XMLElement]:
+        """Find all instances of a specific XML element in the text.
+
+        Args:
+            text: Input text to search for elements.
+            element_name: Name of the element to find.
+
+        Returns:
+            List of XMLElement instances for each found element.
+
+        Raises:
+            ValueError: If the input text is invalid or contains malformed XML.
+        """
+        try:
+            if not text or not isinstance(text, str):
+                raise ValueError("Input text must be a non-empty string")
+
+            elements: list[XMLElement] = []
+            pattern = re.compile(
+                f"<{element_name}>"
+                r"((?:(?!<!\[CDATA\[|]]>).)*?"
+                r"(?:<!\[CDATA\[.*?]]>)?"
+                r"(?:(?!<!\[CDATA\[|]]>).)*?)"
+                f"(?:</\1>|<\1>)",
+                re.DOTALL,
+            )
+
+            for match in pattern.finditer(text):
+                content = match.group(1)
+                cleaned_content, cdata_sections = self._extract_and_remove_cdata(content)
+                cleaned_content = self._clean_content(cleaned_content)
+
+                element = XMLElement(
+                    name=element_name,
+                    content=cleaned_content,
+                    raw=match.group(0),
+                    start_pos=match.start(),
+                    end_pos=match.end(),
+                    cdata_sections=cdata_sections,
+                )
+                elements.append(element)
+
+            return elements
+
+        except Exception as e:
+            error_msg = f"Error extracting XML elements: {str(e)}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)

quantalogic/xml_tool_parser.py

@@ -0,0 +1,99 @@
+"""XML-based tool argument parser.
+
+This module provides functionality for parsing tool arguments from XML-like
+input, with support for validation and error handling.
+"""
+
+from typing import Self
+
+from loguru import logger
+from pydantic import BaseModel, Field
+
+from quantalogic.tools.tool import Tool
+from quantalogic.xml_parser import ToleranceXMLParser
+
+
+class ToolArguments(BaseModel):
+    """Model for storing and validating tool arguments.
+
+    This model provides a structured way to store and validate arguments
+    extracted from XML input, ensuring they meet the tool's requirements.
+
+    Attributes:
+        arguments: Dictionary mapping argument names to their values.
+    """
+
+    arguments: dict[str, str] = Field(
+        default_factory=dict, description="Dictionary mapping argument names to their values"
+    )
+
+
+class ToolParser:
+    """Parser for extracting and validating tool arguments from XML input.
+
+    This class handles the parsing of XML-like input to extract tool arguments,
+    validates them against the tool's requirements, and provides error handling
+    and logging.
+
+    Attributes:
+        tool: The tool instance containing argument specifications.
+        xml_parser: Parser for handling XML-like input.
+    """
+
+    def __init__(self: Self, tool: Tool) -> None:
+        """Initialize the parser with a tool instance.
+
+        Args:
+            tool: Tool instance containing argument specifications.
+        """
+        self.tool = tool
+        self.xml_parser = ToleranceXMLParser()
+
+    def parse(self: Self, xml_string: str) -> dict[str, str]:
+        """Parse XML string and return validated tool arguments.
+
+        Args:
+            xml_string: The XML string containing tool arguments.
+
+        Returns:
+            A dictionary mapping argument names to their values.
+
+        Raises:
+            ValueError: If required arguments are missing or XML is invalid.
+        """
+        try:
+            if not xml_string:
+                error_msg = "Input text must be a non-empty string"
+                logger.error(f"Error extracting XML elements: {error_msg}")
+                raise ValueError(f"Error extracting XML elements: {error_msg}")
+
+            if not xml_string.strip().startswith("<"):
+                error_msg = "Failed to parse XML"
+                logger.error(f"Error extracting XML elements: {error_msg}")
+                raise ValueError(f"Error extracting XML elements: {error_msg}")
+
+            # Parse XML and extract arguments, preserving CDATA content
+            elements = self.xml_parser.extract_elements(xml_string, preserve_cdata=True)
+            logger.debug(f"Extracted elements from XML: {elements}")
+
+            # Check for required arguments
+            for arg in self.tool.arguments:
+                if arg.required and arg.name not in elements:
+                    error_msg = f"argument {arg.name} not found"
+                    logger.error(f"Error extracting XML elements: {error_msg}")
+                    raise ValueError(f"Error extracting XML elements: {error_msg}")
+
+            # Create and validate arguments dictionary
+            argument_dict = {arg.name: elements.get(arg.name, "") for arg in self.tool.arguments}
+
+            # Validate using Pydantic model
+            validated_args = ToolArguments(arguments=argument_dict)
+            logger.debug(f"Successfully parsed arguments: {validated_args.arguments}")
+            return validated_args.arguments
+
+        except ValueError as e:
+            if not str(e).startswith("Error extracting XML elements:"):
+                error_msg = f"Error extracting XML elements: {str(e)}"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+            raise