quantalogic 0.59.3__py3-none-any.whl → 0.61.0__py3-none-any.whl

quantalogic/tools/utilities/selenium_tool.py

@@ -0,0 +1,296 @@
+"""Selenium Tool for web automation and testing.
+
+This tool provides a high-level interface for web automation tasks using Selenium WebDriver.
+It supports common web interactions like navigation, form filling, and element manipulation.
+"""
+
+import asyncio
+from typing import Optional, List, Dict, Any
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.chrome.options import Options
+from webdriver_manager.chrome import ChromeDriverManager
+from pydantic import Field, ConfigDict
+from loguru import logger
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+class SeleniumTool(Tool):
+    """Tool for web automation using Selenium WebDriver."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    name: str = Field(default="selenium_tool")
+    description: str = Field(
+        default=(
+            "Automates web browser interactions using Selenium WebDriver. "
+            "Supports navigation, form filling, clicking, and extracting content. "
+            "Uses Chrome browser in headless mode by default."
+        )
+    )
+    arguments: list = Field(
+        default=[
+            ToolArgument(
+                name="action",
+                arg_type="string",
+                description=(
+                    "The automation action to perform. Available actions: "
+                    "navigate, click, type, extract_text, extract_attribute, wait_for_element"
+                ),
+                required=True,
+                example="navigate",
+            ),
+            ToolArgument(
+                name="url",
+                arg_type="string",
+                description="URL to navigate to (required for 'navigate' action)",
+                required=False,
+                example="https://example.com",
+            ),
+            ToolArgument(
+                name="selector",
+                arg_type="string",
+                description="CSS or XPath selector for target element",
+                required=False,
+                example="#login-button",
+            ),
+            ToolArgument(
+                name="selector_type",
+                arg_type="string",
+                description="Type of selector (css, xpath, id, name, class_name)",
+                required=False,
+                default="css",
+                example="css",
+            ),
+            ToolArgument(
+                name="value",
+                arg_type="string",
+                description="Value to type or attribute to extract",
+                required=False,
+                example="username123",
+            ),
+            ToolArgument(
+                name="timeout",
+                arg_type="int",
+                description="Maximum time to wait for element (seconds)",
+                required=False,
+                default="10",
+                example="10",
+            ),
+        ]
+    )
+
+    driver: Optional[webdriver.Chrome] = Field(default=None, exclude=True)
+    headless: bool = Field(default=True, description="Run browser in headless mode")
+    custom_options: List[str] = Field(default_factory=list, description="Custom Chrome options")
+
+    def __init__(
+        self,
+        headless: bool = True,
+        custom_options: Optional[List[str]] = None,
+        name: str = "selenium_tool"
+    ):
+        """Initialize SeleniumTool with browser configuration.
+
+        Args:
+            headless (bool): Run browser in headless mode. Defaults to True.
+            custom_options (List[str], optional): Custom Chrome options.
+            name (str): Name of the tool instance.
+        """
+        super().__init__(
+            **{
+                "headless": headless,
+                "custom_options": custom_options or [],
+                "name": name,
+            }
+        )
+        self._initialize_driver()
+
+    def _initialize_driver(self):
+        """Initialize Chrome WebDriver with configured options."""
+        try:
+            chrome_options = Options()
+            if self.headless:
+                chrome_options.add_argument("--headless")
+            
+            # Add common options for stability
+            chrome_options.add_argument("--no-sandbox")
+            chrome_options.add_argument("--disable-dev-shm-usage")
+            
+            # Add custom options
+            for option in self.custom_options:
+                chrome_options.add_argument(option)
+
+            # Initialize the driver
+            service = Service(ChromeDriverManager().install())
+            self.driver = webdriver.Chrome(service=service, options=chrome_options)
+            self.driver.implicitly_wait(5)
+            logger.info("Successfully initialized Chrome WebDriver")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize WebDriver: {str(e)}")
+            raise
+
+    def _get_by_method(self, selector_type: str) -> By:
+        """Get the appropriate By method based on selector type.
+
+        Args:
+            selector_type: Type of selector (css, xpath, id, name, class_name)
+
+        Returns:
+            selenium.webdriver.common.by.By method
+        """
+        selector_types = {
+            "css": By.CSS_SELECTOR,
+            "xpath": By.XPATH,
+            "id": By.ID,
+            "name": By.NAME,
+            "class_name": By.CLASS_NAME,
+        }
+        return selector_types.get(selector_type.lower(), By.CSS_SELECTOR)
+
+    async def async_execute(
+        self,
+        action: str,
+        url: Optional[str] = None,
+        selector: Optional[str] = None,
+        selector_type: str = "css",
+        value: Optional[str] = None,
+        timeout: int = 10,
+    ) -> Dict[str, Any]:
+        """Execute a Selenium automation action asynchronously.
+
+        Args:
+            action: The automation action to perform
+            url: URL to navigate to (for navigate action)
+            selector: Element selector
+            selector_type: Type of selector (css, xpath, id, name, class_name)
+            value: Value to type or attribute to extract
+            timeout: Maximum time to wait for element (seconds)
+
+        Returns:
+            Dict containing action result and any extracted data
+        """
+        try:
+            if not self.driver:
+                self._initialize_driver()
+
+            result = {"success": False, "message": "", "data": None}
+
+            # Handle different actions
+            if action == "navigate":
+                if not url:
+                    raise ValueError("URL is required for navigate action")
+                self.driver.get(url)
+                result["success"] = True
+                result["message"] = f"Successfully navigated to {url}"
+
+            elif action in ["click", "type", "extract_text", "extract_attribute", "wait_for_element"]:
+                if not selector:
+                    raise ValueError("Selector is required for element actions")
+
+                # Wait for element
+                by_method = self._get_by_method(selector_type)
+                element = WebDriverWait(self.driver, timeout).until(
+                    EC.presence_of_element_located((by_method, selector))
+                )
+
+                if action == "click":
+                    element.click()
+                    result["success"] = True
+                    result["message"] = f"Successfully clicked element: {selector}"
+
+                elif action == "type":
+                    if not value:
+                        raise ValueError("Value is required for type action")
+                    element.clear()
+                    element.send_keys(value)
+                    result["success"] = True
+                    result["message"] = f"Successfully typed '{value}' into element: {selector}"
+
+                elif action == "extract_text":
+                    text = element.text
+                    result["success"] = True
+                    result["message"] = "Successfully extracted text"
+                    result["data"] = text
+
+                elif action == "extract_attribute":
+                    if not value:
+                        raise ValueError("Attribute name is required for extract_attribute action")
+                    attr_value = element.get_attribute(value)
+                    result["success"] = True
+                    result["message"] = f"Successfully extracted attribute: {value}"
+                    result["data"] = attr_value
+
+                elif action == "wait_for_element":
+                    result["success"] = True
+                    result["message"] = f"Element found: {selector}"
+
+            else:
+                raise ValueError(f"Unknown action: {action}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error in SeleniumTool.async_execute: {str(e)}")
+            return {
+                "success": False,
+                "message": f"Error: {str(e)}",
+                "data": None
+            }
+
+    def execute(
+        self,
+        action: str,
+        url: Optional[str] = None,
+        selector: Optional[str] = None,
+        selector_type: str = "css",
+        value: Optional[str] = None,
+        timeout: int = 10,
+    ) -> Dict[str, Any]:
+        """Synchronous wrapper for async_execute."""
+        return asyncio.run(
+            self.async_execute(
+                action=action,
+                url=url,
+                selector=selector,
+                selector_type=selector_type,
+                value=value,
+                timeout=timeout,
+            )
+        )
+
+    def __del__(self):
+        """Clean up WebDriver when the tool is destroyed."""
+        if self.driver:
+            try:
+                self.driver.quit()
+                logger.info("Successfully closed WebDriver")
+            except Exception as e:
+                logger.error(f"Error closing WebDriver: {str(e)}")
+
+
+if __name__ == "__main__":
+    # Example usage
+    tool = SeleniumTool(headless=True)
+
+    # Navigate to a website
+    result = tool.execute(
+        action="navigate",
+        url="https://example.com"
+    )
+    print("Navigation result:", result)
+
+    # Extract text from an element
+    result = tool.execute(
+        action="extract_text",
+        selector="h1",
+        selector_type="css"
+    )
+    print("Extracted text:", result)
+
+    # Clean up
+    del tool

quantalogic/tools/utilities/vscode_tool.py

@@ -15,7 +15,7 @@ class VSCodeServerTool(Tool):
 
     name: str = "vscode_tool"
     description: str = "Launches a VS Code Server instance for remote development."
-    need_validation: bool = True
+    need_validation: bool = False
     arguments: list = [
         ToolArgument(
             name="workspace_path",

quantalogic/tools/web_navigation/__init__.py

@@ -0,0 +1,5 @@
+"""Web navigation tools package."""
+
+from quantalogic.tools.web_navigation.web_tool import WebNavigationTool
+
+__all__ = ["WebNavigationTool"]

quantalogic/tools/web_navigation/web_tool.py

@@ -0,0 +1,145 @@
+"""Web Navigation Tool using browser-use for automated web interactions."""
+
+import asyncio
+from typing import Callable, Optional
+
+from loguru import logger
+from pydantic import ConfigDict, Field
+
+from browser_use import Agent
+from langchain_openai import ChatOpenAI
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class WebNavigationTool(Tool):
+    """Tool for automated web navigation and interaction using browser-use."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+    name: str = Field(default="web_navigation")
+    description: str = Field(
+        default=(
+            "Navigate and interact with web pages using natural language instructions. "
+            "This tool can perform tasks like searching, comparing prices, filling forms, "
+            "and extracting information from websites."
+        )
+    )
+    arguments: list = Field(
+        default=[
+            ToolArgument(
+                name="task",
+                arg_type="string",
+                description="The web navigation task to perform in natural language",
+                required=True,
+                example="Search Python documentation for asyncio examples",
+            ),
+            ToolArgument(
+                name="model_name",
+                arg_type="string",
+                description="The OpenAI model to use (e.g. gpt-3.5-turbo, gpt-4)",
+                required=True,
+                default="gpt-3.5-turbo",
+                example="gpt-3.5-turbo",
+            ),
+        ]
+    )
+
+    llm: Optional[ChatOpenAI] = Field(default=None, exclude=True)
+    agent: Optional[Agent] = Field(default=None, exclude=True)
+
+    def __init__(
+        self,
+        model_name: str = "gpt-3.5-turbo",
+        name: str = "web_navigation",
+    ) -> None:
+        """Initialize the WebNavigationTool.
+
+        Args:
+            model_name: OpenAI model to use. Defaults to "gpt-3.5-turbo".
+            name: Name of the tool instance. Defaults to "web_navigation".
+        """
+        super().__init__(
+            **{
+                "name": name,
+                "model_name": model_name,
+            }
+        )
+        self.model_post_init(None)
+
+    def model_post_init(self, __context: None) -> None:
+        """Initialize the LLM after model initialization.
+        
+        Args:
+            __context: Unused context parameter.
+        
+        Raises:
+            ValueError: If LLM initialization fails.
+        """
+        try:
+            self.llm = ChatOpenAI(model=self.model_name)
+            logger.debug(f"Initialized WebNavigationTool with model: {self.model_name}")
+        except Exception as e:
+            logger.error(f"Error initializing LLM: {e}")
+            raise ValueError(f"Failed to initialize LLM: {e}") from e
+
+    async def async_execute(self, task: str, model_name: Optional[str] = None) -> str:
+        """Execute the web navigation task asynchronously.
+
+        Args:
+            task: The web navigation task to perform.
+            model_name: Optional override for the LLM model.
+
+        Returns:
+            The result of the web navigation task.
+
+        Raises:
+            ValueError: If task is empty or LLM is not initialized.
+            RuntimeError: If web navigation fails.
+        """
+        if not task:
+            raise ValueError("Task cannot be empty")
+            
+        if not self.llm:
+            raise ValueError("LLM not initialized")
+
+        try:
+            # Create a new Agent instance for each task
+            agent = Agent(
+                task=task,
+                llm=self.llm,
+            )
+            
+            # Run the agent
+            result = await agent.run()
+            logger.debug(f"Completed web navigation task: {task}")
+            return result
+
+        except Exception as e:
+            logger.error(f"Error during web navigation: {e}")
+            raise RuntimeError(f"Web navigation failed: {e}") from e
+
+    def execute(self, task: str, model_name: Optional[str] = None) -> str:
+        """Execute the web navigation task synchronously.
+
+        Args:
+            task: The web navigation task to perform.
+            model_name: Optional override for the LLM model.
+
+        Returns:
+            The result of the web navigation task.
+        """
+        return asyncio.run(self.async_execute(task=task, model_name=model_name))
+
+
+if __name__ == "__main__":
+    # Example usage
+    tool = WebNavigationTool()
+    task = "Search Python documentation for asyncio examples"
+    
+    try:
+        # Synchronous execution
+        result = tool.execute(task=task)
+        print("Navigation Result:")
+        print(result)
+    except Exception as e:
+        logger.error(f"Example failed: {e}")

quantalogic/tools/write_file_tool.py

@@ -1,23 +1,25 @@
 """Tool for writing a file and returning its content."""
 
 import os
+from pathlib import Path
 
+from loguru import logger
 from quantalogic.tools.tool import Tool, ToolArgument
 
 
 class WriteFileTool(Tool):
-    """Tool for writing a text file."""
+    """Tool for writing a text file in /tmp directory."""
 
     name: str = "write_file_tool"
-    description: str = "Writes a file with the given content. The tool will fail if the file already exists when not used in append mode."
+    description: str = "Writes a file with the given content in /tmp directory. The tool will fail if the file already exists when not used in append mode."
     need_validation: bool = True
     arguments: list = [
         ToolArgument(
             name="file_path",
             arg_type="string",
-            description="The path to the file to write. Using an absolute path is recommended.",
+            description="The name of the file to write in /tmp directory. Can include subdirectories within /tmp.",
             required=True,
-            example="/path/to/file.txt",
+            example="/tmp/myfile.txt or myfile.txt",
         ),
         ToolArgument(
             name="content",
@@ -47,50 +49,84 @@ class WriteFileTool(Tool):
         ),
     ]
 
+    def _ensure_tmp_path(self, file_path: str) -> str:
+        """Ensures the file path is within /tmp directory.
+
+        Args:
+            file_path (str): The original file path
+
+        Returns:
+            str: Normalized path within /tmp
+
+        Raises:
+            ValueError: If the path attempts to escape /tmp
+        """
+        # Ensure /tmp exists and is writable
+        tmp_dir = Path("/tmp")
+        if not (tmp_dir.exists() and os.access(tmp_dir, os.W_OK)):
+            raise ValueError("Error: /tmp directory is not accessible")
+
+        # If path doesn't start with /tmp, prepend it
+        if not file_path.startswith("/tmp/"):
+            file_path = os.path.join("/tmp", file_path.lstrip("/"))
+
+        # Resolve the absolute path and check if it's really in /tmp
+        real_path = os.path.realpath(file_path)
+        if not real_path.startswith("/tmp/"):
+            raise ValueError("Error: Cannot write files outside of /tmp directory")
+
+        return real_path
+
     def execute(self, file_path: str, content: str, append_mode: str = "False", overwrite: str = "False") -> str:
-        """Writes a file with the given content.
+        """Writes a file with the given content in /tmp directory.
 
         Args:
-            file_path (str): The path to the file to write.
+            file_path (str): The path to the file to write (will be forced to /tmp).
             content (str): The content to write to the file.
             append_mode (str, optional): If true, append content to existing file. Defaults to "False".
             overwrite (str, optional): If true, overwrite existing file. Defaults to "False".
 
         Returns:
-            str: The content of the file.
+            str: Status message with file path and size.
 
         Raises:
             FileExistsError: If the file already exists and append_mode is False and overwrite is False.
+            ValueError: If attempting to write outside /tmp or if /tmp is not accessible.
         """
-        # Convert mode strings to booleans
-        append_mode_bool = append_mode.lower() in ["true", "1", "yes"]
-        overwrite_bool = overwrite.lower() in ["true", "1", "yes"]
-
-        ## Handle tilde expansion
-        if file_path.startswith("~"):
-            # Expand the tilde to the user's home directory
-            file_path = os.path.expanduser(file_path)
-
-        # Convert relative paths to absolute paths using current working directory
-        if not os.path.isabs(file_path):
-            file_path = os.path.abspath(os.path.join(os.getcwd(), file_path))
-
-        # Ensure parent directory exists
-        os.makedirs(os.path.dirname(file_path), exist_ok=True)
-
-        # Determine file write mode based on append_mode
-        mode = "a" if append_mode_bool else "w"
-
-        # Check if file already exists and not in append mode and not in overwrite mode
-        if os.path.exists(file_path) and not append_mode_bool and not overwrite_bool:
-            raise FileExistsError(
-                f"File {file_path} already exists. Set append_mode=True to append or overwrite=True to overwrite."
-            )
-
-        with open(file_path, mode, encoding="utf-8") as f:
-            f.write(content)
-        file_size = os.path.getsize(file_path)
-        return f"File {file_path} {'appended to' if append_mode_bool else 'written'} successfully. Size: {file_size} bytes."
+        try:
+            # Convert mode strings to booleans
+            append_mode_bool = append_mode.lower() in ["true", "1", "yes"]
+            overwrite_bool = overwrite.lower() in ["true", "1", "yes"]
+
+            # Ensure path is in /tmp and normalize it
+            file_path = self._ensure_tmp_path(file_path)
+
+            # Ensure parent directory exists (only within /tmp)
+            parent_dir = os.path.dirname(file_path)
+            if parent_dir.startswith("/tmp/"):
+                os.makedirs(parent_dir, exist_ok=True)
+
+            # Determine file write mode based on append_mode
+            mode = "a" if append_mode_bool else "w"
+
+            # Check if file already exists and not in append mode and not in overwrite mode
+            if os.path.exists(file_path) and not append_mode_bool and not overwrite_bool:
+                raise FileExistsError(
+                    f"File {file_path} already exists. Set append_mode=True to append or overwrite=True to overwrite."
+                )
+
+            with open(file_path, mode, encoding="utf-8") as f:
+                f.write(content)
+            
+            file_size = os.path.getsize(file_path)
+            return f"File {file_path} {'appended to' if append_mode_bool else 'written'} successfully. Size: {file_size} bytes."
+
+        except (ValueError, FileExistsError) as e:
+            logger.error(f"Write file error: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error writing file: {str(e)}")
+            raise ValueError(f"Failed to write file: {str(e)}")
 
 
 if __name__ == "__main__":

quantalogic/utils/__init__.py

@@ -6,7 +6,6 @@ from .get_environment import get_environment
 from .get_coding_environment import get_coding_environment
 from .get_quantalogic_rules_content import get_quantalogic_rules_file_content
 from .lm_studio_model_info import get_model_list
-from .python_interpreter import interpret_ast
 
 __all__ = [
     "download_http_file",