quantalogic 0.2.10__py3-none-any.whl → 0.2.13__py3-none-any.whl

quantalogic/tools/replace_in_file_tool.py

@@ -204,7 +204,7 @@ class ReplaceInFileTool(Tool):
                 if not block.search:
                     if block.replace:
                         content += f"\n{block.replace}"
-                        logger.info(f"Block {idx}: Appended content")
+                        logger.debug(f"Block {idx}: Appended content")
                     continue
 
                 match_found = False
@@ -218,7 +218,7 @@ class ReplaceInFileTool(Tool):
                             content = f"{content[:start]}{content[end:]}"
                         changes.append((start, start + len(block.replace) if block.replace else start))
                         match_found = True
-                        logger.info(f"Block {idx}: Exact match {'replaced' if block.replace else 'deleted'}")
+                        logger.debug(f"Block {idx}: Exact match {'replaced' if block.replace else 'deleted'}")
 
                 if not match_found:
                     similarity, matched_str = self.find_similar_match(block.search, content)
@@ -232,7 +232,7 @@ class ReplaceInFileTool(Tool):
                             else:
                                 content = f"{content[:start]}{content[end:]}"
                             changes.append((start, start + len(block.replace) if block.replace else start))
-                            logger.info(
+                            logger.debug(
                                 f"Block {idx}: Similar match (similarity={similarity:.1%}) "
                                 f"{'replaced' if block.replace else 'deleted'}"
                             )

quantalogic/tools/ripgrep_tool.py

@@ -136,7 +136,7 @@ class RipgrepTool(Tool):
             return "No files matching the pattern (after .gitignore filtering)"
 
         try:
-            logger.info(f"Executing ripgrep with args: {args}")
+            logger.debug(f"Executing ripgrep with args: {args}")
             # Add filtered files to ripgrep command
             args.extend(filtered_files)
             output = subprocess.check_output([rg_path] + args, text=True, cwd=cwd)
@@ -194,7 +194,7 @@ class RipgrepTool(Tool):
         for path in system_paths + node_paths:
             full_path = Path(__file__).parent.parent / path if str(path).startswith("node_modules") else path
             if full_path.exists():
-                logger.info(f"Found ripgrep at: {full_path}")
+                logger.debug(f"Found ripgrep at: {full_path}")
                 return str(full_path)
 
         # Check system PATH using which/where
@@ -202,7 +202,7 @@ class RipgrepTool(Tool):
             command = "where" if os.name == "nt" else "which"
             rg_path = subprocess.check_output([command, bin_name], text=True).strip()
             if rg_path:
-                logger.info(f"Found ripgrep in PATH at: {rg_path}")
+                logger.debug(f"Found ripgrep in PATH at: {rg_path}")
                 return rg_path
         except subprocess.CalledProcessError:
             logger.debug("Ripgrep not found in system PATH")

quantalogic/tools/serpapi_search_tool.py

@@ -0,0 +1,169 @@
+"""Tool for interacting with SerpApi for search results."""
+
+import os
+
+from serpapi.google_search import GoogleSearch
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class SerpApiSearchTool(Tool):
+    """Tool for retrieving paginated search results from SerpApi.
+
+    This tool provides a convenient interface to SerpAPI's search capabilities,
+    supporting pagination and structured result formatting.
+
+    Example usage:
+    ```python
+    tool = SerpApiTool()
+    results = tool.execute(
+        query="machine learning",
+        page=1,
+        num_results=10
+    )
+    print(results)
+    ```
+
+    The tool handles:
+    - Query validation
+    - Pagination management
+    - API error handling
+    - Result formatting
+    """
+
+    name: str = "serpapi_tool"
+    description: str = (
+        "Retrieves search results from SerpAPI (Google Search) with pagination support. "
+        "Handles multiple pages of results and provides structured output."
+    )
+    arguments: list = [
+        ToolArgument(
+            name="query",
+            arg_type="string",
+            description="The search query to execute",
+            required=True,
+            example="machine learning",
+        ),
+        ToolArgument(
+            name="page",
+            arg_type="int",
+            description="The page number to retrieve (1-based)",
+            required=True,
+            default="1",
+            example="2",
+        ),
+        ToolArgument(
+            name="num_results",
+            arg_type="int",
+            description="Number of results to retrieve per page",
+            required=True,
+            default="10",
+            example="20",
+        ),
+    ]
+
+    def execute(self, query: str, page: int = 1, num_results: int = 10) -> str:
+        """Execute a search query using SerpAPI and return results.
+
+        Args:
+            query: The search query to execute
+            page: The page number to retrieve (1-based)
+            num_results: Number of results to retrieve per page (1-100)
+
+        Returns:
+            Formatted search results as a string with the following format:
+            ==== Page X of results ====
+            1. Title
+               URL
+               Description
+            2. Title
+               URL
+               Description
+            ==== End of page X ====
+
+        Raises:
+            ValueError: If any parameter is invalid
+            RuntimeError: If API request fails or environment variable is missing
+        """
+        # Validate and convert query
+        if not query:
+            raise ValueError("Query must be a non-empty string")
+        try:
+            query = str(query)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Query must be convertible to string: {str(e)}")
+
+        # Validate and convert page
+        try:
+            page = int(page)
+            if page < 1:
+                raise ValueError("Page number must be positive")
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Invalid page number: {str(e)}")
+
+        # Validate and convert num_results
+        try:
+            num_results = int(num_results)
+            if num_results < 1 or num_results > 100:
+                raise ValueError("Number of results must be between 1 and 100")
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Invalid number of results: {str(e)}")
+
+        api_key = os.getenv("SERPAPI_API_KEY")
+        if not api_key:
+            raise RuntimeError("SERPAPI_API_KEY environment variable is not set")
+
+        try:
+            params = {"q": query, "start": (page - 1) * num_results, "num": num_results, "api_key": api_key}
+
+            search = GoogleSearch(params)
+            results = search.get_dict()
+
+            if "error" in results:
+                raise RuntimeError(f"API error: {results['error']}")
+
+            # Format results
+            output = []
+            if "organic_results" in results:
+                for idx, result in enumerate(results["organic_results"], 1):
+                    output.append(f"{idx}. {result.get('title', 'No title')}")
+                    output.append(f"   {result.get('link', 'No URL')}")
+                    output.append(f"   {result.get('snippet', 'No description')}")
+                    output.append("")
+
+            if not output:
+                return "No results found"
+
+            # Add pagination info
+            output.insert(0, f"==== Page {page} of results ====")
+            output.append(f"==== End of page {page} ====")
+
+            return "\n".join(output)
+
+        except Exception as e:
+            raise RuntimeError(f"Search failed: {str(e)}")
+
+
+def main():
+    """Demonstrate SerpApiTool functionality."""
+    try:
+        tool = SerpApiSearchTool()
+
+        # Test basic search functionality
+        print("Testing SerpApiTool with sample query...")
+        results = tool.execute(query="Python programming", page=1, num_results=3)
+        print(results)
+
+        # Test error handling
+        print("\nTesting error handling with invalid query...")
+        try:
+            tool.execute(query="")
+        except ValueError as e:
+            print(f"Caught expected ValueError: {e}")
+
+    except Exception as e:
+        print(f"Error in main: {e}")
+
+
+if __name__ == "__main__":
+    main()

quantalogic/tools/tool.py

@@ -25,10 +25,10 @@ class ToolArgument(BaseModel):
     arg_type: Literal["string", "int", "float", "boolean"] = Field(
         ..., description="The type of the argument. Must be one of: string, integer, float, boolean."
     )
-    description: str | None = Field(None, description="A brief description of the argument.")
+    description: str | None = Field(default=None, description="A brief description of the argument.")
     required: bool = Field(default=False, description="Indicates if the argument is required.")
-    default: str | None = Field(None, description="The default value for the argument.")
-    example: str | None = Field(None, description="An example value to illustrate the argument's usage.")
+    default: str | None = Field(default=None, description="The default value for the argument. This parameter is required.")
+    example: str | None = Field(default=None, description="An example value to illustrate the argument's usage.")
     need_validation: bool = Field(default=False, description="Indicates if the argument needs validation.")
 
 

quantalogic/tools/unified_diff_tool.py

@@ -153,6 +153,7 @@ class PatchError(Exception):
         super().__init__(message)
 
     def __str__(self):
+        """Override the default exception string to include context."""
         msg = [super().__str__()]
         if self.context:
             for key, value in self.context.items():

quantalogic/tools/wikipedia_search_tool.py

@@ -0,0 +1,169 @@
+from typing import Union
+
+"""Tool for interacting with Wikipedia API for search results."""
+
+import requests  # noqa: E402
+
+from quantalogic.tools.tool import Tool, ToolArgument  # noqa: E402
+
+
+class WikipediaSearchTool(Tool):
+    """Tool for retrieving paginated search results from Wikipedia.
+
+    This tool provides a convenient interface to Wikipedia's search API,
+    supporting pagination and structured result formatting.
+
+    Example usage:
+    ```python
+    tool = WikipediaSearchTool()
+    results = tool.execute(
+        query="machine learning",
+        page=1,
+        num_results=10
+    )
+    print(results)
+    ```
+
+    The tool handles:
+    - Query validation
+    - Pagination management
+    - API error handling
+    - Result formatting
+    """
+
+    name: str = "wikipedia_tool"
+    description: str = (
+        "Retrieves search results from Wikipedia with pagination support. "
+        "Handles multiple pages of results and provides structured output."
+    )
+    arguments: list = [
+        ToolArgument(
+            name="query",
+            arg_type="string",
+            description="The search query to execute",
+            required=True,
+            example="machine learning",
+        ),
+        ToolArgument(
+            name="page",
+            arg_type="int",
+            description="The page number to retrieve (1-based)",
+            required=True,
+            default="1",
+            example="2",
+        ),
+        ToolArgument(
+            name="num_results",
+            arg_type="int",
+            description="Number of results to retrieve per page (1-50)",
+            required=True,
+            default="10",
+            example="20",
+        ),
+    ]
+
+    def execute(self, query: str, page: Union[str, int] = 1, num_results: Union[str, int] = 10) -> str:
+        """Execute a search query using Wikipedia API and return results.
+        
+        Args:
+            query: The search query to execute
+            page: The page number to retrieve (1-based)
+            num_results: Number of results to retrieve per page (1-50)
+            
+        Returns:
+            Formatted search results as a string with the following format:
+            ==== Page X of results ====
+            1. Title
+               URL
+               Description
+            2. Title
+               URL
+               Description
+            ==== End of page X ====
+            
+        Raises:
+            ValueError: If any parameter is invalid
+            RuntimeError: If API request fails
+        """
+        if not query or not isinstance(query, str):
+            raise ValueError("Query must be a non-empty string")
+
+        try:
+            page = int(page) if str(page).strip() else 1
+            num_results = int(num_results) if str(num_results).strip() else 10
+        except (ValueError, TypeError) as e:
+            raise ValueError(f"Invalid parameter type: {e}. Expected integers for page and num_results")
+
+        if page < 1:
+            raise ValueError("Page number must be positive")
+            
+        if num_results < 1 or num_results > 50:
+            raise ValueError("Number of results must be between 1 and 50")
+            
+        try:
+            # Wikipedia API endpoint
+            url = "https://en.wikipedia.org/w/api.php"
+            params = {
+                "action": "query",
+                "format": "json",
+                "list": "search",
+                "srsearch": query,
+                "srlimit": num_results,
+                "sroffset": (page - 1) * num_results
+            }
+            
+            response = requests.get(url, params=params)
+            response.raise_for_status()
+            data = response.json()
+            
+            output = []
+            if "query" in data and "search" in data["query"]:
+                for idx, result in enumerate(data["query"]["search"], 1):
+                    title = result.get("title", "No title")
+                    snippet = result.get("snippet", "No description")
+                    url = f"https://en.wikipedia.org/wiki/{title.replace(' ', '_')}"
+                    
+                    output.append(f"{idx}. {title}")
+                    output.append(f"   {url}")
+                    output.append(f"   {snippet}")
+                    output.append("")
+            
+            if not output:
+                return "No results found"
+                
+            output.insert(0, f"==== Page {page} of results ====")
+            output.append(f"==== End of page {page} ====")
+            
+            return "\n".join(output)
+            
+        except Exception as e:
+            raise RuntimeError(f"Search failed: {str(e)}")
+
+
+def main():
+    """Demonstrate WikipediaSearchTool functionality."""
+    try:
+        tool = WikipediaSearchTool()
+        
+        # Test basic search functionality
+        print("Testing WikipediaSearchTool with sample query...")
+        results = tool.execute(
+            query="Python programming",
+            page=1,
+            num_results=3
+        )
+        print(results)
+        
+        # Test error handling
+        print("\nTesting error handling with invalid query...")
+        try:
+            tool.execute(query="")
+        except ValueError as e:
+            print(f"Caught expected ValueError: {e}")
+            
+    except Exception as e:
+        print(f"Error in main: {e}")
+
+
+if __name__ == "__main__":
+    main()

quantalogic/tools/write_file_tool.py

@@ -43,6 +43,7 @@ class WriteFileTool(Tool):
             description="Overwrite mode. If true, existing files can be overwritten. Defaults to False.",
             required=False,
             example="False",
+            default="False",
         ),
     ]
 

quantalogic/utils/check_version.py

@@ -0,0 +1,37 @@
+
+import requests
+from packaging import version
+
+from quantalogic.version import get_version
+
+
+def check_if_is_latest_version() -> (bool,str|None):
+    """Check if the current version is the latest version on PyPI.
+    
+    Returns:
+        bool: True if the current version is the latest, False otherwise
+    """
+    try:
+        current_version = get_version()
+        response = requests.get("https://pypi.org/pypi/quantalogic/json", timeout=5)
+        response.raise_for_status()
+        latest_version = response.json()["info"]["version"]
+        return version.parse(current_version) < version.parse(latest_version), latest_version
+    except (requests.RequestException, KeyError):
+        return False, None
+
+
+def main():
+    """Test the version checking functionality."""
+    is_latest, latest_version = check_if_is_latest_version()
+    if is_latest:
+        print("✅ You're running the latest version")
+    elif latest_version:
+        print(f"⚠️ Update available: {latest_version}")
+    else:
+        print("❌ Could not check version")
+
+if __name__ == "__main__":
+    main()
+
+

quantalogic/utils/download_http_file.py

@@ -35,18 +35,18 @@ def download_http_file(
 
     for attempt in range(max_retries):
         try:
-            logger.info(f"Attempt {attempt + 1} of {max_retries} to download {url}")
+            logger.debug(f"Attempt {attempt + 1} of {max_retries} to download {url}")
             response = requests.get(url, headers=headers, stream=True, timeout=timeout)
             response.raise_for_status()
 
             content_type = response.headers.get("Content-Type", "unknown")
-            logger.info(f"Downloading content with Content-Type: {content_type}")
+            logger.debug(f"Downloading content with Content-Type: {content_type}")
 
             with open(local_path, "wb") as file:
                 for chunk in response.iter_content(chunk_size=chunk_size):
                     file.write(chunk)
 
-            logger.info(f"File successfully downloaded and saved to {local_path}")
+            logger.debug(f"File successfully downloaded and saved to {local_path}")
             return local_path
 
         except HTTPError as http_err:
@@ -70,7 +70,7 @@ def download_http_file(
 
         if attempt < max_retries - 1:
             sleep_duration = delay * (2**attempt)  # Exponential backoff
-            logger.info(f"Retrying in {sleep_duration} seconds...")
+            logger.debug(f"Retrying in {sleep_duration} seconds...")
             sleep(sleep_duration)
 
     logger.error("Max retries reached. Download failed.")

quantalogic/utils/read_http_text_content.py

@@ -45,7 +45,7 @@ def read_http_text_content(
 
     for attempt in range(retries):
         try:
-            logger.info(f"Attempt {attempt + 1} of {retries} to fetch {url}")
+            logger.debug(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)
 
@@ -87,7 +87,7 @@ def read_http_text_content(
 
         if attempt < retries - 1:
             sleep_duration = delay * (2**attempt)  # Exponential backoff
-            logger.info(f"Retrying in {sleep_duration} seconds...")
+            logger.debug(f"Retrying in {sleep_duration} seconds...")
             sleep(sleep_duration)
 
     return None, error_msg

quantalogic/version.py

@@ -1,4 +1,5 @@
+import importlib.metadata
+
 
-VERSION = "0.2.10"
 def get_version() -> str:
-    return VERSION
+    return importlib.metadata.version("quantalogic")

{quantalogic-0.2.10.dist-info → quantalogic-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.10
+Version: 0.2.13
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -12,6 +12,7 @@ Requires-Dist: boto3 (>=1.35.86,<2.0.0)
 Requires-Dist: click (>=8.1.8,<9.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0)
 Requires-Dist: google-auth (>=2.20.0,<3.0.0)
+Requires-Dist: google-search-results (>=2.4.2,<3.0.0)
 Requires-Dist: litellm (>=1.56.4,<2.0.0)
 Requires-Dist: loguru (>=0.7.3,<0.8.0)
 Requires-Dist: markitdown (>=0.0.1a3,<0.0.2)
@@ -19,6 +20,7 @@ Requires-Dist: pathspec (>=0.12.1,<0.13.0)
 Requires-Dist: prompt-toolkit (>=3.0.48,<4.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
+Requires-Dist: serpapi (>=0.1.5,<0.2.0)
 Requires-Dist: tenacity (>=9.0.0,<10.0.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: tree-sitter (>=0.23.2,<0.24.0)
@@ -31,6 +33,7 @@ Requires-Dist: tree-sitter-python (>=0.23.6,<0.24.0)
 Requires-Dist: tree-sitter-rust (>=0.23.2,<0.24.0)
 Requires-Dist: tree-sitter-scala (>=0.23.4,<0.24.0)
 Requires-Dist: tree-sitter-typescript (>=0.23.2,<0.24.0)
+Requires-Dist: types-requests (>=2.32.0.20241016,<3.0.0.0)
 Requires-Dist: uvicorn (>=0.34.0,<0.35.0)
 Requires-Dist: websocket (>=0.2.1,<0.3.0)
 Description-Content-Type: text/markdown
@@ -129,7 +132,7 @@ Options:
                                   e.g. "openrouter/A/gpt-4o-mini").
   --log [info|debug|warning]      Set logging level (info/debug/warning).
   --verbose                       Enable verbose output.
-  --mode [code|basic|interpreter|full|code-basic]
+  --mode [code|basic|interpreter|full|code-basic|search]
                                   Agent mode (code/search/full).
   --help                          Show this message and exit.
 
@@ -140,6 +143,8 @@ Commands:
 ### Commands
 task    Execute a task with the QuantaLogic AI Assistant
 
+
+
 ### Detailed Usage
 
 #### Agent Modes
@@ -379,16 +384,19 @@ By integrating these tools into its architecture, QuantaLogic allows agents to p
 
 ### Tools Documentation
 
+
+
 #### Overview of Tools
 
 | Category               | Tools                                                                                             |
 |-----------------------|---------------------------------------------------------------------------------------------------|
-| Task Automation        | Agent Tool, Task Complete Tool, Input Question Tool, Execute Bash Command Tool                  |
-| Script Execution       | Python Tool, Node.js Tool, Elixir Tool                                                            |
-| File Operations        | Read File Tool, Write File Tool, Edit Whole Content Tool, Replace In File Tool                   |
-| Code Analysis          | Search Definition Names Tool, Ripgrep Tool                                                        |
-| Content Generation      | LLM Tool, LLMVisionTool                                                                           |
-| Utility and Management  | Download HTTP File Tool, List Directory Tool, Markitdown Tool, Unified Diff Tool                 |
+| 1. Search Tools        | 1.1 SerpAPI Search Tool, 1.2 Wikipedia Search Tool                                               |
+| 2. Task Automation     | Agent Tool, Task Complete Tool, Input Question Tool, Execute Bash Command Tool                  |
+| 3. Script Execution    | Python Tool, Node.js Tool, Elixir Tool                                                            |
+| 4. File Operations     | Read File Tool, Write File Tool, Edit Whole Content Tool, Replace In File Tool                   |
+| 5. Code Analysis       | Search Definition Names Tool, Ripgrep Tool                                                        |
+| 6. Content Generation  | LLM Tool, LLMVisionTool                                                                           |
+| 7. Utility & Management| Download HTTP File Tool, List Directory Tool, Markitdown Tool, Unified Diff Tool                 |
 
 ---
 
@@ -787,6 +795,51 @@ result = markitdown_tool.execute(markdown_path="./path/to/file.md")
 print("Processed Markdown Output:", result)
 ```
 
+---
+
+### 19. SerpAPI Search Tool
+
+The **SerpAPI Search Tool** allows agents to perform web searches using the SerpAPI service.
+
+##### Parameters
+| Parameter | Type   | Description                     | Example                     |
+|-----------|--------|---------------------------------|-----------------------------|
+| query     | string | The search query to execute     | "latest AI research papers" |
+| location  | string | Geographic location for results | "United States"             |
+| num       | int    | Number of results to return     | 5                           |
+
+##### Example Usage
+```python
+from quantalogic.tools import SerpAPISearchTool
+
+search_tool = SerpAPISearchTool()
+results = search_tool.execute(query="latest AI research", location="United States", num=5)
+print(results)
+```
+
+---
+
+### 20. Wikipedia Search Tool
+
+The **Wikipedia Search Tool** enables agents to search and retrieve information from Wikipedia.
+
+##### Parameters
+
+| Parameter | Type   | Description                     | Example                     |
+|-----------|--------|---------------------------------|-----------------------------|
+| query     | string | The search query to execute     | "Artificial Intelligence"   |
+| lang      | string | Language code for results       | "en"                        |
+| sentences | int    | Number of summary sentences     | 3                           |
+
+##### Example Usage
+```python
+from quantalogic.tools import WikipediaSearchTool
+
+wiki_tool = WikipediaSearchTool()
+results = wiki_tool.execute(query="Artificial Intelligence", lang="en", sentences=3)
+print(results)
+```
+```
 
 #### Creating Custom Tools