quantalogic 0.61.3__py3-none-any.whl → 0.92__py3-none-any.whl

quantalogic/agent.py

@@ -23,7 +23,6 @@ from quantalogic.utils import get_environment
 from quantalogic.utils.ask_user_validation import console_ask_for_user_validation
 from quantalogic.xml_parser import ToleranceXMLParser
 from quantalogic.xml_tool_parser import ToolParser
-import uuid
 
 # Maximum ratio occupancy of the occupied memory
 MAX_OCCUPANCY = 90.0

quantalogic/flow/__init__.py

@@ -1,40 +1,22 @@
-"""
-Flow Package Initialization
+"""Stub alias for backwards compatibility: re-export Flow API from the quantalogic_flow package."""
+from quantalogic_flow import (
+    Nodes,
+    Workflow,
+    WorkflowEngine,
+    WorkflowManager,
+    extract_workflow_from_file,
+    generate_executable_script,
+    generate_mermaid_diagram,
+    validate_workflow_definition,
+)
 
-This module initializes the flow package and provides package-level imports.
-Now supports nested workflows for hierarchical flow definitions.
-
-Key Visualization Utilities:
-- generate_mermaid_diagram(): Convert workflow definitions to visual Mermaid flowcharts
-    - Supports pastel-colored node styling
-    - Generates interactive, readable workflow diagrams
-    - Handles complex workflows with multiple node types
-
-    - Generates descriptive labels
-    - Supports conditional node detection
-"""
-
-from loguru import logger
-
-# Expose key components for easy importing
-from .flow import Nodes, Workflow, WorkflowEngine
-from .flow_extractor import extract_workflow_from_file
-from .flow_generator import generate_executable_script
-from .flow_manager import WorkflowManager
-from .flow_mermaid import generate_mermaid_diagram
-from .flow_validator import validate_workflow_definition
-
-# Define which symbols are exported when using `from flow import *`
 __all__ = [
-    "WorkflowManager",
+    "extract_workflow_from_file",
+    "generate_executable_script",
+    "generate_mermaid_diagram",
     "Nodes",
+    "validate_workflow_definition",
     "Workflow",
     "WorkflowEngine",
-    "generate_mermaid_diagram",
-    "extract_workflow_from_file",
-    "generate_executable_script",
-    "validate_workflow_definition"
+    "WorkflowManager",
 ]
-
-# Package-level logger configuration
-logger.info("Initializing Quantalogic Flow Package")

quantalogic/main.py

@@ -18,6 +18,11 @@ load_dotenv()
 
 # Configure logger
 logger.remove()
+logger.add(
+    sys.stderr,
+    level="ERROR",  # Changed from WARNING to ERROR
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>"
+)
 
 from rich.console import Console  # noqa: E402
 from rich.panel import Panel  # noqa: E402
@@ -98,9 +103,9 @@ def restore_terminal(old_settings):
 )
 @click.option(
     "--log",
-    type=click.Choice(["info", "debug", "warning"]),
+    type=click.Choice(["info", "debug", "warning", "error"]),
     default="info",
-    help="Set logging level (info/debug/warning).",
+    help="Set logging level (info/debug/warning/error).",
 )
 @click.option("--verbose", is_flag=True, help="Enable verbose output.")
 @click.option("--mode", type=click.Choice(AGENT_MODES), default="basic", help="Agent mode (code/search/full/chat).")
@@ -196,9 +201,9 @@ def cli(
 @click.option("--mode", type=click.Choice(AGENT_MODES), default="basic", help="Agent mode (code/search/full/chat).")
 @click.option(
     "--log",
-    type=click.Choice(["info", "debug", "warning"]),
+    type=click.Choice(["info", "debug", "warning", "error"]),
     default="info",
-    help="Set logging level (info/debug/warning).",
+    help="Set logging level (info/debug/warning/error).",
 )
 @click.option(
     "--vision-model-name",
@@ -318,9 +323,9 @@ def list_models(search: Optional[str] = None):
 )
 @click.option(
     "--log",
-    type=click.Choice(["info", "debug", "warning"]),
+    type=click.Choice(["info", "debug", "warning", "error"]),
     default="info",
-    help="Set logging level (info/debug/warning).",
+    help="Set logging level (info/debug/warning/error).",
 )
 @click.option("--verbose", is_flag=True, help="Enable verbose output.")
 @click.option(

quantalogic/tools/action_gen.py

@@ -8,8 +8,8 @@ from typing import Callable, Dict, List
 import litellm
 import typer
 from loguru import logger
+from quantalogic_pythonbox.python_interpreter import execute_async
 
-from quantalogic.python_interpreter import execute_async
 from quantalogic.tools.tool import Tool, ToolArgument
 
 # Configure loguru to log to a file with rotation, matching original

quantalogic/tools/tool.py

@@ -1,500 +1,8 @@
-"""Module for defining tool arguments and base tool classes.
-
-This module provides base classes and data models for creating configurable tools
-with type-validated arguments and execution methods.
-"""
-
-import ast
-import asyncio  # Added for asynchronous support
-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.
-
-    Attributes:
-        name: The name of the argument.
-        arg_type: The type of the argument (integer, float, boolean).
-        description: Optional description of the argument.
-        required: Indicates if the argument is mandatory.
-        default: Optional default value for the argument.
-        example: Optional example value to illustrate the argument's usage.
-    """
-
-    name: str = Field(..., description="The name of the argument.")
-    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(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(
-        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.")
-
-class ToolDefinition(BaseModel):
-    """Base class for defining tool configurations without execution logic.
-
-    Attributes:
-        name: Unique name of the tool.
-        description: Brief description of the tool's functionality.
-        arguments: List of arguments the tool accepts.
-        return_type: The return type of the tool's execution method. Defaults to "str".
-        need_validation: Flag to indicate if tool requires validation.
-    """
-
-    model_config = ConfigDict(extra="allow", validate_assignment=True)
-
-    name: str = Field(..., description="The unique name of the tool.")
-    description: str = Field(..., description="A brief description of what the tool does.")
-    arguments: list[ToolArgument] = Field(default_factory=list, description="A list of arguments the tool accepts.")
-    return_type: str = Field(default="str", description="The return type of the tool's execution method.")
-    need_validation: bool = Field(
-        default=False,
-        description="When True, requires user confirmation before execution. Useful for tools that perform potentially destructive operations.",
-    )
-    need_post_process: bool = Field(
-        default=True,
-        description="When True, requires user confirmation before execution. Useful for tools that perform potentially destructive operations.",
-    )
-    need_variables: bool = Field(
-        default=False,
-        description="When True, provides access to the agent's variable store. Required for tools that need to interpolate variables (e.g., Jinja templates).",
-    )
-    need_caller_context_memory: bool = Field(
-        default=False,
-        description="When True, provides access to the agent's conversation history. Useful for tools that need context from previous interactions.",
-    )
-
-    def get_properties(self, exclude: list[str] | None = None) -> dict[str, Any]:
-        """Return a dictionary of all non-None properties, excluding Tool class fields and specified fields.
-
-        Args:
-            exclude: Optional list of field names to exclude from the result
-
-        Returns:
-            Dictionary of property names and values, excluding Tool class fields and specified fields.
-        """
-        exclude = exclude or []
-        tool_fields = {
-            "name",
-            "description",
-            "arguments",
-            "return_type",
-            "need_validation",
-            "need_variables",
-            "need_caller_context_memory",
-        }
-        properties = {}
-
-        for name, value in self.__dict__.items():
-            if name not in tool_fields and name not in exclude and value is not None and not name.startswith("_"):
-                properties[name] = value
-
-        return properties
-
-    def to_json(self) -> str:
-        """Convert the tool to a JSON string representation.
-
-        Returns:
-            A JSON string of the tool's configuration.
-        """
-        return self.model_dump_json()
-
-    def to_markdown(self) -> str:
-        """Create a comprehensive Markdown representation of the tool.
-
-        Returns:
-            A detailed Markdown string representing the tool's configuration and usage.
-        """
-        # Tool name and description
-        markdown = f"`{self.name}`:\n"
-        markdown += f"- **Description**: {self.description}\n\n"
-
-        properties_injectable = self.get_injectable_properties_in_execution()
-
-        # Parameters section
-        if self.arguments:
-            markdown += "- **Parameters**:\n"
-            parameters = ""
-            for arg in self.arguments:
-                # Skip if parameter name matches an object property with non-None value
-                if properties_injectable.get(arg.name) is not None:
-                    continue
-
-                required_status = "required" if arg.required else "optional"
-                # Prioritize example, then default, then create a generic description
-                value_info = ""
-                if arg.example is not None:
-                    value_info = f" (example: `{arg.example}`)"
-                elif arg.default is not None:
-                    value_info = f" (default: `{arg.default}`)"
-
-                parameters += (
-                    f"  - `{arg.name}`: " f"({required_status}{value_info})\n" f"    {arg.description or ''}\n"
-                )
-            if len(parameters) > 0:
-                markdown += parameters + "\n\n"
-            else:
-                markdown += "None\n\n"
-
-        # Usage section with XML-style example
-        markdown += "**Usage**:\n"
-        markdown += "```xml\n"
-        markdown += f"<{self.name}>\n"
-
-        # Generate example parameters
-        for arg in self.arguments:
-            if properties_injectable.get(arg.name) is not None:
-                continue
-            # Prioritize example, then default, then create a generic example
-            example_value = arg.example or arg.default or f"Your {arg.name} here"
-            markdown += f"  <{arg.name}>{example_value}</{arg.name}>\n"
-
-        markdown += f"</{self.name}>\n"
-        markdown += "```\n"
-
-        return markdown
-
-    def get_non_injectable_arguments(self) -> list[ToolArgument]:
-        """Get arguments that cannot be injected from properties.
-
-        Returns:
-            List of ToolArgument instances that cannot be injected by the agent.
-        """
-        properties_injectable = self.get_injectable_properties_in_execution()
-
-        return [arg for arg in self.arguments if properties_injectable.get(arg.name) is None]
-
-    def get_injectable_properties_in_execution(self) -> dict[str, Any]:
-        """Get injectable properties excluding tool arguments.
-
-        Returns:
-            A dictionary of property names and values, excluding tool arguments and None values.
-        """
-        # This method is defined here in ToolDefinition and overridden in Tool
-        # For ToolDefinition, it returns an empty dict since it has no execution context yet
-        return {}
-
-    def to_docstring(self) -> str:
-        """Convert the tool definition into a Google-style docstring with function signature.
-
-        Returns:
-            A string formatted as a valid Python docstring representing the tool's configuration,
-            including the function signature and return type.
-        """
-        # Construct the function signature
-        signature_parts = []
-        for arg in self.arguments:
-            # Base argument: name and type
-            arg_str = f"{arg.name}: {arg.arg_type}"
-            # Add default value if present
-            if arg.default is not None:
-                arg_str += f" = {arg.default}"
-            signature_parts.append(arg_str)
-        signature = f"def {self.name}({', '.join(signature_parts)}) -> {self.return_type}:"
-
-        # Start with the signature and description
-        docstring = f'"""\n{signature}\n\n{self.description}\n\n'
-        
-        # Add Arguments section if there are any
-        if self.arguments:
-            docstring += "Args:\n"
-            for arg in self.arguments:
-                # Base argument line: name and type
-                arg_line = f"    {arg.name} ({arg.arg_type})"
-                
-                # Add optional/required status and default/example if present
-                details = []
-                if not arg.required:
-                    details.append("optional")
-                if arg.default is not None:
-                    details.append(f"defaults to {arg.default}")
-                if arg.example is not None:
-                    details.append(f"e.g., {arg.example}")
-                if details:
-                    arg_line += f" [{', '.join(details)}]"
-                
-                # Add description if present
-                if arg.description:
-                    arg_line += f": {arg.description}"
-                
-                docstring += f"{arg_line}\n"
-        
-        # Add Returns section
-        docstring += f"Returns:\n    {self.return_type}: The result of the tool execution.\n"
-        
-        # Close the docstring
-        docstring += '"""'
-        
-        return docstring
-
-class Tool(ToolDefinition):
-    """Extended class for tools with execution capabilities.
-
-    Inherits from ToolDefinition and adds execution functionality.
-    """
-
-    @field_validator("arguments", mode="before")
-    @classmethod
-    def validate_arguments(cls, v: Any) -> list[ToolArgument]:
-        """Validate and convert arguments to ToolArgument instances.
-
-        Args:
-            v: Input arguments to validate.
-
-        Returns:
-            A list of validated ToolArgument instances.
-        """
-        if isinstance(v, list):
-            return [
-                ToolArgument(**arg)
-                if isinstance(arg, dict)
-                else arg
-                if isinstance(arg, ToolArgument)
-                else ToolArgument(name=str(arg), type=type(arg).__name__)
-                for arg in v
-            ]
-        return []
-
-    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.
-
-        Args:
-            **kwargs: Keyword arguments for tool execution.
-
-        Returns:
-            A string representing the result of tool execution.
-        """
-        # Check if execute is implemented in the subclass
-        if self.__class__.execute is Tool.execute:
-            # If not implemented, run the async version synchronously
-            return asyncio.run(self.async_execute(**kwargs))
-        raise NotImplementedError("This method should be implemented by subclasses.")
-
-    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.
-        Subclasses can override this method to provide a native asynchronous implementation for
-        operations that benefit from async I/O (e.g., network requests).
-
-        Args:
-            **kwargs: Keyword arguments for tool execution.
-
-        Returns:
-            A string representing the result of tool execution.
-        """
-        # Check if execute_async is implemented in the subclass
-        if self.__class__.async_execute is Tool.async_execute:
-            return await asyncio.to_thread(self.execute, **kwargs)
-        raise NotImplementedError("This method should be implemented by subclasses.")
-
-    def get_injectable_properties_in_execution(self) -> dict[str, Any]:
-        """Get injectable properties excluding tool arguments.
-
-        Returns:
-            A dictionary of property names and values, excluding tool arguments and None values.
-        """
-        # Get argument names from tool definition
-        argument_names = {arg.name for arg in self.arguments}
-
-        # Get properties excluding arguments and filter out None values
-        properties = self.get_properties(exclude=["arguments"])
-        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
-        ))
-
-    # Determine return type from type hints
-    return_type = type_hints.get("return", str)
-    return_type_str = type_map.get(return_type, "string")
-
-    # Define Tool subclass
-    class GeneratedTool(Tool):
-        def __init__(self, *args: Any, **kwargs: Any):
-            super().__init__(*args, name=name, description=description, arguments=arguments, return_type=return_type_str, **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__":
-    # Basic tool with argument
-    tool = Tool(
-        name="my_tool",
-        description="A simple tool",
-        arguments=[ToolArgument(name="arg1", arg_type="string")]
-    )
-    print("Basic Tool Markdown:")
-    print(tool.to_markdown())
-    print("Basic Tool Docstring:")
-    print(tool.to_docstring())
-    print()
-
-    # Tool with injectable field (undefined)
-    class MyTool(Tool):
-        field1: str | None = Field(default=None, description="Field 1 description")
-
-    tool_with_fields = MyTool(
-        name="my_tool1",
-        description="A simple tool with a field",
-        arguments=[ToolArgument(name="field1", arg_type="string")]
-    )
-    print("Tool with Undefined Field Markdown:")
-    print(tool_with_fields.to_markdown())
-    print("Injectable Properties (should be empty):", tool_with_fields.get_injectable_properties_in_execution())
-    print("Tool with Undefined Field Docstring:")
-    print(tool_with_fields.to_docstring())
-    print()
-
-    # Tool with defined injectable field
-    tool_with_fields_defined = MyTool(
-        name="my_tool2",
-        description="A simple tool with a defined field",
-        field1="field1_value",
-        arguments=[ToolArgument(name="field1", arg_type="string")]
-    )
-    print("Tool with Defined Field Markdown:")
-    print(tool_with_fields_defined.to_markdown())
-    print("Injectable Properties (should include field1):", tool_with_fields_defined.get_injectable_properties_in_execution())
-    print("Tool with Defined Field Docstring:")
-    print(tool_with_fields_defined.to_docstring())
-    print()
-
-    # 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
-
-    sync_tool = create_tool(add)
-    print("Synchronous Tool Markdown:")
-    print(sync_tool.to_markdown())
-    print("Synchronous Tool Docstring:")
-    print(sync_tool.to_docstring())
-    print("Execution result:", sync_tool.execute(a=5, b=3))
-    print()
-
-    # 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}"
-
-    async_tool = create_tool(greet)
-    print("Asynchronous Tool Markdown:")
-    print(async_tool.to_markdown())
-    print("Asynchronous Tool Docstring:")
-    print(async_tool.to_docstring())
-    print("Execution result:", asyncio.run(async_tool.async_execute(name="Alice")))
-    print()
-
-    # Comprehensive tool for to_docstring demonstration with custom return type
-    docstring_tool = Tool(
-        name="sample_tool",
-        description="A sample tool for testing docstring generation.",
-        arguments=[
-            ToolArgument(name="x", arg_type="int", description="The first number", required=True),
-            ToolArgument(name="y", arg_type="float", description="The second number", default="0.0", example="1.5"),
-            ToolArgument(name="verbose", arg_type="boolean", description="Print extra info", default="False")
-        ],
-        return_type="int"  # Custom return type
-    )
-    print("Comprehensive Tool Markdown:")
-    print(docstring_tool.to_markdown())
-    print("Comprehensive Tool Docstring with Custom Return Type:")
-    print(docstring_tool.to_docstring())
+from quantalogic_toolbox.tool import Tool, ToolArgument, create_tool
+
+__all__ = [
+    "ToolArgument",
+    "Tool",
+    "create_tool",
+]
+