quantalogic 0.50.29__py3-none-any.whl → 0.52.0__py3-none-any.whl

quantalogic/tools/__init__.py

@@ -28,7 +28,7 @@ from .sequence_tool import SequenceTool
 from .serpapi_search_tool import SerpApiSearchTool
 from .sql_query_tool import SQLQueryTool
 from .task_complete_tool import TaskCompleteTool
-from .tool import Tool, ToolArgument
+from .tool import Tool, ToolArgument, create_tool
 from .unified_diff_tool import UnifiedDiffTool
 from .wikipedia_search_tool import WikipediaSearchTool
 from .write_file_tool import WriteFileTool
@@ -65,5 +65,6 @@ __all__ = [
     'ToolArgument',
     'UnifiedDiffTool',
     'WikipediaSearchTool',
-    'WriteFileTool'
+    'WriteFileTool',
+    "create_tool"
 ]

quantalogic/tools/tool.py

@@ -4,11 +4,16 @@ This module provides base classes and data models for creating configurable tool
 with type-validated arguments and execution methods.
 """
 
+import ast
 import asyncio  # Added for asynchronous support
-from typing import Any, Literal
+import inspect
+from typing import Any, Callable, Literal, TypeVar
 
+from docstring_parser import parse as parse_docstring
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
+# Type variable for create_tool to preserve function signature
+F = TypeVar('F', bound=Callable[..., Any])
 
 class ToolArgument(BaseModel):
     """Represents an argument for a tool with validation and description.
@@ -204,7 +209,7 @@ class Tool(ToolDefinition):
             ]
         return []
 
-    def execute(self, **kwargs) -> str:
+    def execute(self, **kwargs: Any) -> str:
         """Execute the tool with provided arguments.
 
         If not implemented by a subclass, falls back to the asynchronous execute_async method.
@@ -221,7 +226,7 @@ class Tool(ToolDefinition):
             return asyncio.run(self.async_execute(**kwargs))
         raise NotImplementedError("This method should be implemented by subclasses.")
 
-    async def async_execute(self, **kwargs) -> str:
+    async def async_execute(self, **kwargs: Any) -> str:
         """Asynchronous version of execute.
 
         By default, runs the synchronous execute method in a separate thread using asyncio.to_thread.
@@ -253,6 +258,96 @@ class Tool(ToolDefinition):
         return {name: value for name, value in properties.items() if value is not None and name in argument_names}
 
 
+def create_tool(func: F) -> Tool:
+    """Create a Tool instance from a Python function using AST analysis.
+
+    Analyzes the function's source code to extract its name, docstring, and arguments,
+    then constructs a Tool subclass with appropriate execution logic.
+
+    Args:
+        func: The Python function (sync or async) to convert into a Tool.
+
+    Returns:
+        A Tool subclass instance configured based on the function.
+
+    Raises:
+        ValueError: If the input is not a valid function or lacks a function definition.
+    """
+    if not callable(func):
+        raise ValueError("Input must be a callable function")
+
+    # Get source code and parse with AST
+    try:
+        source = inspect.getsource(func).strip()
+        tree = ast.parse(source)
+    except (OSError, TypeError, SyntaxError) as e:
+        raise ValueError(f"Failed to parse function source: {e}")
+
+    # Ensure root node is a function definition
+    if not tree.body or not isinstance(tree.body[0], (ast.FunctionDef, ast.AsyncFunctionDef)):
+        raise ValueError("Source must define a single function")
+    func_def = tree.body[0]
+
+    # Extract metadata
+    name = func_def.name
+    docstring = ast.get_docstring(func_def) or ""
+    parsed_doc = parse_docstring(docstring)
+    description = parsed_doc.short_description or f"Tool generated from {name}"
+    param_docs = {p.arg_name: p.description for p in parsed_doc.params}
+    is_async = isinstance(func_def, ast.AsyncFunctionDef)
+
+    # Get type hints using typing module
+    from typing import get_type_hints
+    type_hints = get_type_hints(func)
+    type_map = {int: "int", str: "string", float: "float", bool: "boolean"}
+
+    # Process arguments
+    args = func_def.args
+    defaults = [None] * (len(args.args) - len(args.defaults)) + [
+        ast.unparse(d) if isinstance(d, ast.AST) else str(d) for d in args.defaults
+    ]
+    arguments: list[ToolArgument] = []
+
+    for i, arg in enumerate(args.args):
+        arg_name = arg.arg
+        default = defaults[i]
+        required = default is None
+
+        # Determine argument type
+        hint = type_hints.get(arg_name, str)  # Default to str if no hint
+        arg_type = type_map.get(hint, "string")  # Fallback to string for unmapped types
+
+        # Use docstring or default description
+        description = param_docs.get(arg_name, f"Argument {arg_name}")
+
+        # Create ToolArgument
+        arguments.append(ToolArgument(
+            name=arg_name,
+            arg_type=arg_type,
+            description=description,
+            required=required,
+            default=default,
+            example=default if default else None
+        ))
+
+    # Define Tool subclass
+    class GeneratedTool(Tool):
+        def __init__(self, *args: Any, **kwargs: Any):
+            super().__init__(*args, name=name, description=description, arguments=arguments, **kwargs)
+            self._func = func
+
+        if is_async:
+            async def async_execute(self, **kwargs: Any) -> str:
+                result = await self._func(**kwargs)
+                return str(result)
+        else:
+            def execute(self, **kwargs: Any) -> str:
+                result = self._func(**kwargs)
+                return str(result)
+
+    return GeneratedTool()
+
+
 if __name__ == "__main__":
     tool = Tool(name="my_tool", description="A simple tool", arguments=[ToolArgument(name="arg1", arg_type="string")])
     print(tool.to_markdown())
@@ -274,3 +369,34 @@ if __name__ == "__main__":
     )
     print(tool_with_fields_defined.to_markdown())
     print(tool_with_fields_defined.get_injectable_properties_in_execution())
+
+    # Test create_tool with synchronous function
+    def add(a: int, b: int = 0) -> int:
+        """Add two numbers.
+        
+        Args:
+            a: First number.
+            b: Second number (optional).
+        """
+        return a + b
+
+    # Test create_tool with asynchronous function
+    async def greet(name: str) -> str:
+        """Greet a person.
+        
+        Args:
+            name: Name of the person.
+        """
+        await asyncio.sleep(0.1)  # Simulate async work
+        return f"Hello, {name}"
+
+    # Create and test tools
+    sync_tool = create_tool(add)
+    print("\nSynchronous Tool:")
+    print(sync_tool.to_markdown())
+    print("Execution result:", sync_tool.execute(a=5, b=3))
+
+    async_tool = create_tool(greet)
+    print("\nAsynchronous Tool:")
+    print(async_tool.to_markdown())
+    print("Execution result:", asyncio.run(async_tool.async_execute(name="Alice")))