This lesson's interactive features are locked, please to keep using them

Run Python

If you thought allowing an LLM to write files was a bad idea...

You ain't seen nothin' yet! (Praise the basilisk.)

It's time to build the functionality for our agent to run arbitrary Python code.

Now, it's worth pausing to point out the inherent security risks here. We have a few things going for us:

We'll only allow the LLM to run code in a specific directory (the working_directory).
We'll use a 30-second timeout to prevent it from running indefinitely.

But aside from that... yes, the LLM can run arbitrary code that we place (or it places) in the working directory... so be careful. As long as you use this AI agent only for the simple tasks we're doing in this course, you should be fine.

Do not give this program to others for them to use! It doesn't have all the security and safety features that a production AI agent would have. This is for learning purposes only.

Assignment

Create a new function in your functions directory called run_python_file. Here's the signature to use:

def run_python_file(
    working_directory: str, file_path: str, args: list[str] | None = None
) -> str:

If the file_path is outside the working_directory, return the error string below. (Hopefully this part is easy by now!)
```
f'Error: Cannot execute "{file_path}" as it is outside the permitted working directory'
```
Make sure that file_path exists and points to a regular file (rather than, e.g., a directory). os.path.isfile() answers both questions at once. If this check fails, return an error string:
```
f'Error: "{file_path}" does not exist or is not a regular file'
```
If the file name doesn't end with .py, return an error string:
```
f'Error: "{file_path}" is not a Python file'
```
Assuming all those checks passed, we're going to use a subprocess to run the file. But first we need to build the command to run – in the form of a list of strings. Start with something like this:
```
command = ["python", absolute_file_path]
```
If any additional args were provided, add them to the command list. You can use the .extend() method to do this.
Use the subprocess.run() function to run the command that you built. This will return a CompletedProcess object, which you'll want to assign to a variable. Also, when calling subprocess.run(), make sure to provide the necessary arguments to:
1. Set the working directory properly.
2. Capture output (i.e., stdout and stderr).
3. Decode the output to strings, rather than bytes; this is done by setting text=True.
4. Set a timeout of 30 seconds to prevent infinite execution.
Build an output string based on the CompletedProcess object:
1. If the process exited with a non-zero returncode, include "Process exited with code X".
2. If both stdout and stderr contained no output (both of which are attributes of CompletedProcess), add "No output produced".
3. Otherwise, include any text in stdout prefixed with STDOUT:, and any text in stderr prefixed with STDERR:.
Return the output string.
As usual, if any exception is raised anywhere in this function, catch it and return an error string:
```
f"Error: executing Python file: {e}"
```
Create another new test module at the root of your project, test_run_python_file.py. It should be similar in structure to the test modules that you've written for other functions. Include the following test cases, printing each result:
1. run_python_file("calculator", "main.py") (should print the calculator's usage instructions)
2. run_python_file("calculator", "main.py", ["3 + 5"]) (should run the calculator... which gives a kinda nasty rendered result)
3. run_python_file("calculator", "tests.py") (should run the calculator's tests successfully)
4. run_python_file("calculator", "../main.py") (this should return an error)
5. run_python_file("calculator", "nonexistent.py") (this should return an error)
6. run_python_file("calculator", "lorem.txt") (this should return an error)

Run and submit the CLI tests.