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

quantalogic/codeact/agent.py

@@ -5,8 +5,8 @@ from typing import Callable, Dict, List, Optional, Tuple
 from jinja2 import Environment, FileSystemLoader
 from loguru import logger
 from lxml import etree
+from quantalogic_pythonbox import execute_async
 
-from quantalogic.python_interpreter import execute_async
 from quantalogic.tools import Tool
 
 from .constants import MAX_GENERATE_PROGRAM_TOKENS, MAX_HISTORY_TOKENS, MAX_TOKENS, TEMPLATE_DIR

quantalogic/codeact/cli.py

@@ -4,11 +4,9 @@ from typing import Callable, List, Optional, Union
 import typer
 from loguru import logger
 
-from quantalogic.tools import create_tool
-
-from .agent import Agent  # Import only Agent from agent.py
-from .constants import DEFAULT_MODEL, LOG_FILE
-from .events import (  # Import events from events.py
+from quantalogic.codeact.agent import Agent  # Import only Agent from agent.py
+from quantalogic.codeact.constants import DEFAULT_MODEL, LOG_FILE
+from quantalogic.codeact.events import (  # Import events from events.py
     ActionExecutedEvent,
     ActionGeneratedEvent,
     ErrorOccurredEvent,
@@ -22,6 +20,8 @@ from .events import (  # Import events from events.py
     ToolExecutionErrorEvent,
     ToolExecutionStartedEvent,
 )
+from quantalogic.tools import create_tool
+
 from .tools_manager import Tool, get_default_tools
 from .utils import XMLResultHandler
 

quantalogic/codeact/tools_manager.py

@@ -130,6 +130,6 @@ def get_default_tools(model: str) -> List[Tool]:
         # RipgrepTool(), 
         # SearchDefinitionNamesTool(),
         #TaskCompleteTool(), 
-        WriteFileTool(), 
+        WriteFileTool(disable_ensure_tmp_path=True),
         AgentTool(model=model),
     ]

quantalogic/tools/action_gen_safe.py

@@ -0,0 +1,340 @@
+import ast
+import asyncio
+from functools import partial
+from typing import Callable, Dict, List
+
+import litellm
+import typer
+from loguru import logger
+
+from quantalogic.tools.tool import Tool, ToolArgument
+from quantalogic.utils.python_interpreter import ASTInterpreter
+
+# Configure loguru to log to a file with rotation
+logger.add("action_gen_safe.log", rotation="10 MB", level="DEBUG")
+
+# Initialize Typer app
+app = typer.Typer()
+
+# Define tool classes with logging in async_execute
+class AddTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="add_tool",
+            description="Adds two numbers and returns the sum.",
+            arguments=[
+                ToolArgument(name="a", arg_type="int", description="First number", required=True),
+                ToolArgument(name="b", arg_type="int", description="Second number", required=True)
+            ],
+            return_type="int"
+        )
+    
+    async def async_execute(self, **kwargs) -> str:
+        logger.info(f"Adding {kwargs['a']} and {kwargs['b']}")
+        return str(int(kwargs["a"]) + int(kwargs["b"]))
+
+class MultiplyTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="multiply_tool",
+            description="Multiplies two numbers and returns the product.",
+            arguments=[
+                ToolArgument(name="x", arg_type="int", description="First number", required=True),
+                ToolArgument(name="y", arg_type="int", description="Second number", required=True)
+            ],
+            return_type="int"
+        )
+    
+    async def async_execute(self, **kwargs) -> str:
+        logger.info(f"Multiplying {kwargs['x']} and {kwargs['y']}")
+        return str(int(kwargs["x"]) * int(kwargs["y"]))
+
+class ConcatTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="concat_tool",
+            description="Concatenates two strings.",
+            arguments=[
+                ToolArgument(name="s1", arg_type="string", description="First string", required=True),
+                ToolArgument(name="s2", arg_type="string", description="Second string", required=True)
+            ],
+            return_type="string"
+        )
+    
+    async def async_execute(self, **kwargs) -> str:
+        logger.info(f"Concatenating '{kwargs['s1']}' and '{kwargs['s2']}'")
+        return kwargs["s1"] + kwargs["s2"]
+
+class AgentTool(Tool):
+    def __init__(self, model: str = "gemini/gemini-2.0-flash"):
+        super().__init__(
+            name="agent_tool",
+            description="Generates text using a language model based on a system prompt and user prompt.",
+            arguments=[
+                ToolArgument(name="system_prompt", arg_type="string", description="System prompt to guide the model's behavior", required=True),
+                ToolArgument(name="prompt", arg_type="string", description="User prompt to generate a response for", required=True),
+                ToolArgument(name="temperature", arg_type="float", description="Temperature for generation (0 to 1)", required=True)
+            ],
+            return_type="string"
+        )
+        self.model = model
+    
+    async def async_execute(self, **kwargs) -> str:
+        system_prompt = kwargs["system_prompt"]
+        prompt = kwargs["prompt"]
+        temperature = float(kwargs["temperature"])
+        
+        # Validate temperature
+        if not 0 <= temperature <= 1:
+            logger.error(f"Temperature {temperature} is out of range (0-1)")
+            raise ValueError("Temperature must be between 0 and 1")
+        
+        logger.info(f"Generating text with model {self.model}, temperature {temperature}")
+        try:
+            response = await litellm.acompletion(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=temperature,
+                max_tokens=1000  # Reasonable default for text generation
+            )
+            generated_text = response.choices[0].message.content.strip()
+            logger.debug(f"Generated text: {generated_text}")
+            return generated_text
+        except Exception as e:
+            logger.error(f"Failed to generate text with {self.model}: {str(e)}")
+            raise RuntimeError(f"Text generation failed: {str(e)}")
+
+# Asynchronous function to generate the program
+async def generate_program(task_description: str, tools: List[Tool], model: str, max_tokens: int) -> str:
+    """
+    Asynchronously generate a Python program that solves a given task using a list of tools.
+
+    Args:
+        task_description (str): A description of the task to be solved.
+        tools (List[Tool]): A list of Tool objects available for use.
+        model (str): The litellm model to use for code generation.
+        max_tokens (int): Maximum number of tokens for the generated response.
+
+    Returns:
+        str: A string containing a complete Python program.
+    """
+    logger.debug(f"Generating program for task: {task_description}")
+    # Collect tool docstrings
+    tool_docstrings = "\n\n".join([tool.to_docstring() for tool in tools])
+
+    # Construct the prompt for litellm
+    prompt = f"""
+You are a Python code generator. Your task is to create a Python program that solves the following task:
+"{task_description}"
+
+You have access to the following pre-defined async tool functions, as defined with their signatures and descriptions:
+
+{tool_docstrings}
+
+Instructions:
+1. Generate a Python program as a single string.
+2. Include only the import for asyncio (import asyncio).
+3. Define an async function named main() that solves the task.
+4. Use the pre-defined tool functions (e.g., add_tool, multiply_tool, concat_tool) directly by calling them with await and the appropriate arguments as specified in their descriptions.
+5. Do not redefine the tool functions within the program; assume they are already available in the namespace.
+6. Return the program as a string enclosed in triple quotes (\"\"\"program\"\"\")).
+7. Do not include asyncio.run(main()) or any code outside the main() function definition.
+8. Do not include explanatory text outside the program string.
+9. Express all string variables as multiline strings (\"\"\"\nstring\n\"\"\"), always start a string at the beginning of a line.
+10. Always print the result at the end of the program.
+11. Never call the main() function.
+12. Never use not defined variables, modules, or functions.
+
+Example task: "Add 5 and 7 and print the result"
+Example output:
+\"\"\"import asyncio
+async def main():
+    result = await add_tool(a=5, b=7)
+    print(result)
+\"\"\"
+"""
+    
+    logger.debug(f"Prompt sent to litellm:\n{prompt}")
+    
+    try:
+        # Call litellm asynchronously to generate the program
+        logger.debug(f"Calling litellm with model {model}")
+        response = await litellm.acompletion(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are a Python code generator."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=max_tokens,
+            temperature=0.3
+        )
+        generated_code = response.choices[0].message.content.strip()
+        logger.debug("Code generation successful")
+    except Exception as e:
+        logger.error(f"Failed to generate code: {str(e)}")
+        raise typer.BadParameter(f"Failed to generate code with model '{model}': {str(e)}")
+
+    # Clean up the output
+    if generated_code.startswith('"""') and generated_code.endswith('"""'):
+        generated_code = generated_code[3:-3]
+    elif generated_code.startswith("```python") and generated_code.endswith("```"):
+        generated_code = generated_code[9:-3].strip()
+    
+    return generated_code
+
+# Async core logic for generate
+async def generate_core(task: str, model: str, max_tokens: int):
+    logger.info(f"Starting generate command for task: {task}")
+    # Input validation
+    if not task.strip():
+        logger.error("Task description is empty")
+        raise typer.BadParameter("Task description cannot be empty")
+    if max_tokens <= 0:
+        logger.error("max-tokens must be positive")
+        raise typer.BadParameter("max-tokens must be a positive integer")
+
+    # Initialize tools
+    tools = [
+        AddTool(),
+        MultiplyTool(),
+        ConcatTool(),
+        AgentTool(model=model)  # Include AgentTool with the specified model
+    ]
+
+    # Generate the program
+    try:
+        program = await generate_program(task, tools, model, max_tokens)
+    except Exception as e:
+        logger.error(f"Failed to generate program: {str(e)}")
+        typer.echo(typer.style(f"Error: {str(e)}", fg=typer.colors.RED))
+        raise typer.Exit(code=1)
+
+    logger.debug(f"Generated program:\n{program}")
+    # Output the generated program
+    typer.echo(typer.style("Generated Python Program:", fg=typer.colors.GREEN, bold=True))
+    typer.echo(program)
+    
+    # Attempt to execute the program using the safe interpreter
+    typer.echo("\n" + typer.style("Executing the program safely:", fg=typer.colors.GREEN, bold=True))
+    try:
+        # Create instances of tools
+        add_tool_instance = AddTool()
+        multiply_tool_instance = MultiplyTool()
+        concat_tool_instance = ConcatTool()
+        agent_tool_instance = AgentTool(model=model)
+
+        # Define the allowed modules
+        allowed_modules = ["asyncio"]
+        
+        # Create a namespace with our tools
+        namespace = {
+            "add_tool": add_tool_instance.async_execute,
+            "multiply_tool": multiply_tool_instance.async_execute,
+            "concat_tool": concat_tool_instance.async_execute,
+            "agent_tool": agent_tool_instance.async_execute,
+        }
+        
+        # Parse the program to AST
+        program_ast = ast.parse(program)
+        
+        # Extract imports first to ensure they're allowed
+        for node in program_ast.body:
+            if isinstance(node, ast.Import):
+                for name in node.names:
+                    if name.name not in allowed_modules:
+                        raise ValueError(f"Import not allowed: {name.name}")
+            elif isinstance(node, ast.ImportFrom):
+                if node.module not in allowed_modules:
+                    raise ValueError(f"Import from not allowed: {node.module}")
+        
+        # Find the main function in the AST
+        main_func_node = None
+        for node in program_ast.body:
+            if isinstance(node, ast.AsyncFunctionDef) and node.name == "main":
+                main_func_node = node
+                break
+        
+        if not main_func_node:
+            logger.warning("No async main() function found in generated code")
+            typer.echo(typer.style("Warning: No async main() function found", fg=typer.colors.YELLOW))
+            return
+            
+        # Execute the code safely to define functions in the namespace
+        # Use a custom ASTInterpreter directly instead of calling interpret_code
+        interpreter = ASTInterpreter(allowed_modules=allowed_modules, source=program)
+        
+        # Add tools to the interpreter's environment
+        interpreter.env_stack[0].update({
+            "add_tool": add_tool_instance.async_execute,
+            "multiply_tool": multiply_tool_instance.async_execute,
+            "concat_tool": concat_tool_instance.async_execute,
+            "agent_tool": agent_tool_instance.async_execute,
+        })
+        
+        # First, execute all non-main code (imports and other top-level code)
+        for node in program_ast.body:
+            if not isinstance(node, ast.AsyncFunctionDef) or node.name != "main":
+                await interpreter.visit(node, wrap_exceptions=True)
+        
+        # Then execute the main function definition
+        for node in program_ast.body:
+            if isinstance(node, ast.AsyncFunctionDef) and node.name == "main":
+                await interpreter.visit(node, wrap_exceptions=True)
+        
+        # Get the main function from the environment
+        main_func = interpreter.get_variable("main")
+        
+        # Execute the main function in the current event loop
+        logger.debug("Executing main() function")
+        await main_func()
+        
+        logger.info("Program executed successfully")
+        typer.echo(typer.style("Execution completed successfully", fg=typer.colors.GREEN))
+    
+    except SyntaxError as e:
+        logger.error(f"Syntax error in generated code: {e}")
+        typer.echo(typer.style(f"Syntax error: {e}", fg=typer.colors.RED))
+    except Exception as e:
+        logger.error(f"Execution error: {e}")
+        typer.echo(typer.style(f"Execution failed: {e}", fg=typer.colors.RED))
+
+# Synchronous callback to invoke async generate_core
+@app.callback(invoke_without_command=True)
+def generate(
+    task: str = typer.Argument(
+        ...,
+        help="The task description to generate a program for (e.g., 'Add 5 and 7 and print the result')"
+    ),
+    model: str = typer.Option(
+        "gemini/gemini-2.0-flash",
+        "--model",
+        "-m",
+        help="The litellm model to use for generation (e.g., 'gpt-3.5-turbo', 'gpt-4')"
+    ),
+    max_tokens: int = typer.Option(
+        4000,
+        "--max-tokens",
+        "-t",
+        help="Maximum number of tokens for the generated response (default: 4000)"
+    )
+):
+    """
+    Asynchronously generate a Python program based on a task description using specified tools and model.
+    Executes the program in a controlled, safe environment.
+
+    Examples:
+        $ python action_gen_safe.py "Add 5 and 7 and print the result"
+        $ python action_gen_safe.py "Concatenate 'Hello' and 'World' and print it" --model gpt-4 --max-tokens 5000
+    """
+    asyncio.run(generate_core(task, model, max_tokens))
+
+# Entry point to start the app
+def main():
+    logger.debug("Starting script execution")
+    app()
+
+if __name__ == "__main__":
+    main()

quantalogic/tools/write_file_tool.py

@@ -10,10 +10,10 @@ from quantalogic.tools.tool import Tool, ToolArgument
 
 
 class WriteFileTool(Tool):
-    """Tool for writing a text file in /tmp directory."""
+    """Tool for writing a text file to a specified path."""
 
     name: str = "write_file_tool"
-    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."
+    description: str = "Writes a file to the specified path. The tool will fail if the file already exists when not used in append mode."
     need_validation: bool = True
 
     disable_ensure_tmp_path: bool = Field(default=False)
@@ -25,7 +25,7 @@ class WriteFileTool(Tool):
                 arg_type="string",
                 description="The path to the file to write. By default, paths will be forced to /tmp directory unless disable_ensure_tmp_path is enabled. Can include subdirectories.",
                 required=True,
-                example="/tmp/myfile.txt or myfile.txt",
+                example="/tmp/myfile.txt or ./myfile.txt",
             ),
             ToolArgument(
                 name="content",
@@ -107,11 +107,8 @@ class WriteFileTool(Tool):
             # Ensure path is in /tmp and normalize it
             if not self.disable_ensure_tmp_path:
                 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)
+                if not file_path.startswith('/tmp/'):
+                    raise ValueError('File path must be under /tmp when disable_ensure_tmp_path is False')
 
             # Determine file write mode based on append_mode
             mode = "a" if append_mode_bool else "w"
@@ -122,6 +119,8 @@ class WriteFileTool(Tool):
                     f"File {file_path} already exists. Set append_mode=True to append or overwrite=True to overwrite."
                 )
 
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
             with open(file_path, mode, encoding="utf-8") as f:
                 f.write(content)
             

{quantalogic-0.61.2.dist-info → quantalogic-0.61.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.61.2
+Version: 0.61.3
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -34,6 +34,7 @@ Requires-Dist: psutil (>=7.0.0,<8.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pytest-asyncio (>=0.25.3,<0.26.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: quantalogic-pythonbox (>=0.8.3,<0.9.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: serpapi (>=0.1.5,<0.2.0)

{quantalogic-0.61.2.dist-info → quantalogic-0.61.3.dist-info}/RECORD

@@ -3,8 +3,8 @@ quantalogic/agent.py,sha256=VChZXFLEsIIrBtXVQZ-FGZ72GCUXDL3g9br8Vo1t5V8,75072
 quantalogic/agent_config.py,sha256=HNXHmu3BiT4q9i-L2wJKUh6PuiZ_ryTNaB7ga24kaJo,8334
 quantalogic/agent_factory.py,sha256=soActorasOqs5g6NmlyeEjRYbJceIGGg7wuUS-vA898,6878
 quantalogic/codeact/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-quantalogic/codeact/agent.py,sha256=oajib7OsfBp230sg_IjmknqYsFz_lSURC39fj5brsP4,22454
-quantalogic/codeact/cli.py,sha256=FBqnqPUobq6ySuTL9oTLyXSenHC6V7wsCWAbNDK_xec,10810
+quantalogic/codeact/agent.py,sha256=lF5Cq9e_XrBrGwhEZoNNbV-FxAMM2S12_u2og5W4994,22445
+quantalogic/codeact/cli.py,sha256=Nxo5Biv08yvA72c860ikKI6Ebp0vlygoVrIMCpYsSxA,10867
 quantalogic/codeact/constants.py,sha256=_xJ2QwP5wUE9vwSDm0JTSMC4GVjXAaxHTwcZBjDCoKk,244
 quantalogic/codeact/events.py,sha256=4itxGsz54Te9vim13JC8QhacnLQ8cqtOOIyOWUrKFi0,1530
 quantalogic/codeact/llm_util.py,sha256=9HqN0prWyAgdt6FYtdzjWoIoPpDavHQ7EIIfJr2Fi8w,2749
@@ -12,7 +12,7 @@ quantalogic/codeact/prompts/error_format.j2,sha256=_8fNWxDr3U1Fq8SdzwRIBNsNG1WvP
 quantalogic/codeact/prompts/generate_action.j2,sha256=v0LXFxz6L2EwIPesu_mYSVqyNctjHOCIfdawHCb2rtc,1289
 quantalogic/codeact/prompts/generate_program.j2,sha256=05_1bAwIJLLBKt4o9c7sRWLHIoiHPyGl9OquieMZT5g,2048
 quantalogic/codeact/prompts/response_format.j2,sha256=TwO43dEG-3justNigpX4yyzGR1TGS3YDlpJQq8Z5Vf4,355
-quantalogic/codeact/tools_manager.py,sha256=l2cpHLuQP-MW0uP8d2e6IdMToeveaIOdilwDGPjPciY,4464
+quantalogic/codeact/tools_manager.py,sha256=Q_BGtqN3E8QGbobtaYMpQXqqTv_eb5HmIoZelleUMeI,4491
 quantalogic/codeact/utils.py,sha256=B7Xowk4id6Sgoyl0eBJsi6JiKa-BAwnj0a5z70vrV1M,5308
 quantalogic/coding_agent.py,sha256=WFfabRwwPZFV3Pw3seLKpSrFE9Li4pz8Z8mCdsUIDi8,5532
 quantalogic/config.py,sha256=bmPI2rvQ9M8Zdl1H7K588JgJdnkxSE0L5_i5aBqsagA,564
@@ -57,25 +57,6 @@ quantalogic/prompts/task_summary_prompt.j2,sha256=fcjV96nqi6jsfR8l6uyep20rCaOi-z
 quantalogic/prompts/tools_prompt.j2,sha256=ZjvTAZtAk-FmzDb1QuyDJg1hzo-FqayQ7wN_ytHAi2s,385
 quantalogic/prompts/variables_prompt.j2,sha256=N3OsMbzy3PfEUqYZVF_34wVidhh2ghVToSgdRCv2qgM,231
 quantalogic/prompts.py,sha256=zqmyosq4hdYpzHI-FG0m5CKV2wQnjgyMJf6Vo1ZaLW4,1982
-quantalogic/python_interpreter/__init__.py,sha256=cNYxH9jy5QEAPZo44zmJzy3Kci14e0lL2h20Cbrs7RQ,675
-quantalogic/python_interpreter/assignment_visitors.py,sha256=t6ttdYuwjcz8VtqJS5vMaaUUG6GbEhoNmnNDUj8dZiI,2771
-quantalogic/python_interpreter/base_visitors.py,sha256=aD1pc3DbdlPdjQ3yJTYhBqNpN6tant7NOHXShts8coo,765
-quantalogic/python_interpreter/class_visitors.py,sha256=FUgBVg_TmpAdLdLlYlPnruSm8iViijW3gTBQveJjkpI,862
-quantalogic/python_interpreter/comprehension_visitors.py,sha256=AdPn047QUeoG5D1VD4wU2JuXS2KBTwLOIGbApmx9s7A,8468
-quantalogic/python_interpreter/context_visitors.py,sha256=_4-Xfk0wzsla2rSIJZYEyYK4yIK7yRZWX6-HNBFSWTs,2137
-quantalogic/python_interpreter/control_flow_visitors.py,sha256=trJ0Led1pPWKyseQF7BbIF5LFopkOiRDSVHz9Hi7-hI,3662
-quantalogic/python_interpreter/exception_visitors.py,sha256=dbRuk2CaEZN-tYrzcRxZQh_UdLfpcW7wwrG8iQoGeE8,4571
-quantalogic/python_interpreter/exceptions.py,sha256=mL4G9a0PZrvW_hAjkweMohvN8ryZsZOiIOolZUDSq9Y,1296
-quantalogic/python_interpreter/execution.py,sha256=bggzv-GMnFe0Pkt00T4IlPUnDMsuqcHO1Qo0Wq6rEbs,8420
-quantalogic/python_interpreter/function_utils.py,sha256=1LCEqCDt0p0uBTeC6rcre84r_j06jc6HuWLZ5Fc8m8M,18133
-quantalogic/python_interpreter/function_visitors.py,sha256=WcGBWXZ_A7vekkrejL2XTuVPyqsKymK4svJr6-kR-OI,11317
-quantalogic/python_interpreter/import_visitors.py,sha256=AgqFM8SO1wuJluDRsDGBwm-FQ5K374pQrXgbXXEBgPI,1331
-quantalogic/python_interpreter/interpreter_core.py,sha256=PV_XFx0xhUG9ACvhz3FGat2FSaXK3C031HjRizHbox0,16646
-quantalogic/python_interpreter/literal_visitors.py,sha256=TX9-02rn093OFTDvKkhp0PbTsXqIU1voBfbxs-TXfu0,3715
-quantalogic/python_interpreter/misc_visitors.py,sha256=_olOaGD04icqKDqeEFUPIY5Nq0cH5pdGkq-8T6xbilM,6758
-quantalogic/python_interpreter/operator_visitors.py,sha256=WTf4EfwE88lMoTKjuL8UBNpbwJ8Z6DTdrwvVffVw-Ic,4048
-quantalogic/python_interpreter/scope.py,sha256=HSSbtDAMeDbE5LjSckTHvFlhcOUGv8UzxpI4NgUbp5U,257
-quantalogic/python_interpreter/visit_handlers.py,sha256=dGh7BxwGArnBnmwxVzpV6l_uXQ5J6esUm2xKtXne30M,2610
 quantalogic/quantlitellm.py,sha256=nf-awyOxP0ANoAPGHNvHfdLu8gNn65L39gl7x4saIQc,5550
 quantalogic/search_agent.py,sha256=tr0cwscJ4wu_G1aumjFyvGHQ0eQv5OL5sxj17s6Ocls,2470
 quantalogic/server/__init__.py,sha256=8sz_PYAUCrkM6JM5EAUeIzNM4NPW6j6UT72JVkc21WQ,91
@@ -91,6 +72,7 @@ quantalogic/task_runner.py,sha256=NB7TqNuwCstCAsTkjGcJSQRapNk8-iXe7d_2qf-fs1s,15
 quantalogic/tool_manager.py,sha256=vNA7aBKgdU3wpw_goom6i9rg_64pNZapNxvg4cUhhCI,6983
 quantalogic/tools/__init__.py,sha256=NU_M6VYYaAbSUtb2Qdu1lsYaDh0G3f_8jnrZTsBD0eY,2390
 quantalogic/tools/action_gen.py,sha256=M16voPq7tMR1qiCKTaZAusmVchFbBIluuBbLQH9kEG4,15580
+quantalogic/tools/action_gen_safe.py,sha256=7doUtPnV9oxBc02N_N-xcMxmfT9Nd6gHfkNU7MtwVUk,13996
 quantalogic/tools/agent_tool.py,sha256=MXCXxWHRch7VK4UWhtRP1jeI8Np9Ne2CUGo8vm1oZiM,3064
 quantalogic/tools/composio/__init__.py,sha256=Yo9ygNx0qQILVhIfRgqpO8fgnCgp5WoZMd3Hm5D20GY,429
 quantalogic/tools/composio/composio.py,sha256=icVHA_Scr1pViBhahGGBGBRBl9JSB3hGSqpgQzAIUH8,17627
@@ -188,7 +170,7 @@ quantalogic/tools/utils/generate_database_report.py,sha256=IU_XGTDNXfJXxzpHR1F4c
 quantalogic/tools/web_navigation/__init__.py,sha256=O7SkVqbGwN4zt8Sm3H8AHF9451FSgI5h0J3fDj1rFS4,142
 quantalogic/tools/web_navigation/web_tool.py,sha256=AxAxQLUNwCElqxP2ceOOjHVY80ck-Md-uNsjHdR9ErA,4721
 quantalogic/tools/wikipedia_search_tool.py,sha256=LXQSPH8961Efw2QNxKe-cD5ZiIYD3ufEgrxH4y5uB74,5180
-quantalogic/tools/write_file_tool.py,sha256=aevO9koB1Gz96PJCu-hQuW014qTzrnoSpcMc6eke5mI,5583
+quantalogic/tools/write_file_tool.py,sha256=cOheTr2ZTWNbPHlB1PRhc1btJ2mW8TvE5PLQFIdbUb8,5578
 quantalogic/utils/__init__.py,sha256=E442CJQuTohKzgI0Wrd4NZEpKascFjz6F4Vy8Y1c_0Y,634
 quantalogic/utils/ask_user_validation.py,sha256=kSr7TXPTpsLR9zgwpGWgvffx8-cKAC_rdFRdLqwC22A,1176
 quantalogic/utils/async_utils.py,sha256=FOizWRbHdsZwoD36dNErzunfwPlE7zDprS6RXcWuWSo,963
@@ -209,8 +191,8 @@ quantalogic/version_check.py,sha256=JyQFTNMDWtpHCLnN-BiakzB2cyXf6kUFsTjvmSruZi4,
 quantalogic/welcome_message.py,sha256=o4tHdgabNuIV9kbIDPgS3_2yzJhayK30oKad2UouYDc,3020
 quantalogic/xml_parser.py,sha256=bLLwIwO-VEHWF3heNS7nuPC8wgdYw9F_fVZZNW1figY,11728
 quantalogic/xml_tool_parser.py,sha256=hGHA1q20JUoTNTbZYmi4FTdA5I25-AGEIP8DwZgQCNA,3897
-quantalogic-0.61.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quantalogic-0.61.2.dist-info/METADATA,sha256=38TzrZH-h5sMLtIgRGcMlOdTBXtGh-tSndq7AeFmJxA,32975
-quantalogic-0.61.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quantalogic-0.61.2.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
-quantalogic-0.61.2.dist-info/RECORD,,
+quantalogic-0.61.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quantalogic-0.61.3.dist-info/METADATA,sha256=6VPi8J-lWUhZsEKVuCKFuJaWChJ2bHRO6qCQN47I_Cw,33029
+quantalogic-0.61.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quantalogic-0.61.3.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
+quantalogic-0.61.3.dist-info/RECORD,,

quantalogic/python_interpreter/__init__.py

@@ -1,23 +0,0 @@
-# quantalogic/utils/__init__.py
-from .exceptions import BreakException, ContinueException, ReturnException, WrappedException, has_await
-from .execution import AsyncExecutionResult, execute_async, interpret_ast, interpret_code
-from .function_utils import AsyncFunction, Function, LambdaFunction
-from .interpreter_core import ASTInterpreter
-from .scope import Scope
-
-__all__ = [
-    'ASTInterpreter',
-    'execute_async',
-    'interpret_ast',
-    'interpret_code',
-    'AsyncExecutionResult',
-    'ReturnException',
-    'BreakException',
-    'ContinueException',
-    'WrappedException',
-    'has_await',
-    'Function',
-    'AsyncFunction',
-    'LambdaFunction',
-    'Scope',
-]

quantalogic/python_interpreter/assignment_visitors.py

@@ -1,63 +0,0 @@
-import ast
-from typing import Any
-
-from .interpreter_core import ASTInterpreter
-
-async def visit_Assign(self: ASTInterpreter, node: ast.Assign, wrap_exceptions: bool = True) -> None:
-    value: Any = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-    for target in node.targets:
-        if isinstance(target, ast.Subscript):
-            obj = await self.visit(target.value, wrap_exceptions=wrap_exceptions)
-            key = await self.visit(target.slice, wrap_exceptions=wrap_exceptions)
-            obj[key] = value
-        else:
-            await self.assign(target, value)
-
-async def visit_AugAssign(self: ASTInterpreter, node: ast.AugAssign, wrap_exceptions: bool = True) -> Any:
-    if isinstance(node.target, ast.Name):
-        current_val: Any = self.get_variable(node.target.id)
-    else:
-        current_val: Any = await self.visit(node.target, wrap_exceptions=wrap_exceptions)
-    right_val: Any = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-    op = node.op
-    if isinstance(op, ast.Add):
-        result: Any = current_val + right_val
-    elif isinstance(op, ast.Sub):
-        result = current_val - right_val
-    elif isinstance(op, ast.Mult):
-        result = current_val * right_val
-    elif isinstance(op, ast.Div):
-        result = current_val / right_val
-    elif isinstance(op, ast.FloorDiv):
-        result = current_val // right_val
-    elif isinstance(op, ast.Mod):
-        result = current_val % right_val
-    elif isinstance(op, ast.Pow):
-        result = current_val**right_val
-    elif isinstance(op, ast.BitAnd):
-        result = current_val & right_val
-    elif isinstance(op, ast.BitOr):
-        result = current_val | right_val
-    elif isinstance(op, ast.BitXor):
-        result = current_val ^ right_val
-    elif isinstance(op, ast.LShift):
-        result = current_val << right_val
-    elif isinstance(op, ast.RShift):
-        result = current_val >> right_val
-    else:
-        raise Exception("Unsupported augmented operator: " + str(op))
-    await self.assign(node.target, result)
-    return result
-
-async def visit_AnnAssign(self: ASTInterpreter, node: ast.AnnAssign, wrap_exceptions: bool = True) -> None:
-    value = await self.visit(node.value, wrap_exceptions=wrap_exceptions) if node.value else None
-    annotation = await self.visit(node.annotation, wrap_exceptions=True)
-    if isinstance(node.target, ast.Name):
-        self.type_hints[node.target.id] = annotation
-    if value is not None or node.simple:
-        await self.assign(node.target, value)
-
-async def visit_NamedExpr(self: ASTInterpreter, node: ast.NamedExpr, wrap_exceptions: bool = True) -> Any:
-    value = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-    await self.assign(node.target, value)
-    return value

quantalogic/python_interpreter/base_visitors.py

@@ -1,20 +0,0 @@
-import ast
-from typing import Any
-
-from .exceptions import WrappedException
-from .interpreter_core import ASTInterpreter
-
-async def visit_Module(self: ASTInterpreter, node: ast.Module, wrap_exceptions: bool = True) -> Any:
-    last_value = None
-    for stmt in node.body:
-        last_value = await self.visit(stmt, wrap_exceptions=True)
-    return last_value
-
-async def visit_Expr(self: ASTInterpreter, node: ast.Expr, wrap_exceptions: bool = True) -> Any:
-    return await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-
-async def visit_Pass(self: ASTInterpreter, node: ast.Pass, wrap_exceptions: bool = True) -> None:
-    return None
-
-async def visit_TypeIgnore(self: ASTInterpreter, node: ast.TypeIgnore, wrap_exceptions: bool = True) -> None:
-    pass

quantalogic/python_interpreter/class_visitors.py

@@ -1,22 +0,0 @@
-import ast
-from typing import Any, Dict, List
-
-from .function_utils import Function
-from .interpreter_core import ASTInterpreter
-
-async def visit_ClassDef(self: ASTInterpreter, node: ast.ClassDef, wrap_exceptions: bool = True) -> Any:
-    base_frame = {}
-    self.env_stack.append(base_frame)
-    bases = [await self.visit(base, wrap_exceptions=True) for base in node.bases]
-    try:
-        for stmt in node.body:
-            await self.visit(stmt, wrap_exceptions=True)
-        class_dict = {k: v for k, v in self.env_stack[-1].items() if k not in ["__builtins__"]}
-        cls = type(node.name, tuple(bases), class_dict)
-        for name, value in class_dict.items():
-            if isinstance(value, Function):
-                value.defining_class = cls
-        self.env_stack[-2][node.name] = cls
-        return cls
-    finally:
-        self.env_stack.pop()