streamlit-execute 0.1.0
Streamlit component that allows you to execute Python code using Pyodide.
Requires Python: >=3.7

>[!WARNING]
> This is a work in progress. This package currently only supports python code execution. The goal is to support other languages as well.

# streamlit-execute

A streamlit component package that allows you to execute code on the client (which keeps the user code execution a safer distance from the server/backend). Currently, only python code execution is supported. Pyodide (Webassembly) is used for python code execution. The goal is to support other languages as well.

## Installation instructions

```sh
pip install streamlit-execute
```

## Usage instructions

There are 3 functions you will likely need to call to execute python code. If you dont care about Interpreter-like features, you can just call `init` function and give it the code you want to execute. 

```python
import streamlit as st
from streamlit_execute import init

# Execute code
response = init("print('Hello World!')")
st.write(response)

```

If you want to execute more code in the same interpreter, you can use the `run` function. This will execute the code you give it in the same interpreter that was created by the `init` function.

```python
import streamlit as st
import streamlit_execute as se

# Create an interpreter
response = se.init()

# Execute code
response_add = se.run("5 + 5")
st.write(response_add)
```

The `run` function creates another component that will pass code to the *correct* interpreter and receive the *corresponding* result. It will then pass the result back to Streamlit in the return value of the `run` function.

However, the above will not work without calling an additional function that sets up communication between the interpreter component and all of the `run` components. This is done by calling the `connect` function.

```python
import streamlit as st
import streamlit_execute as se

# Create an interpreter
response = se.init()

# Connect all run calls to the interpreter
se.connect()

# Execute code
response_add = se.run("5 + 5")
st.write(response_add)
```

Note that `run` components are intended to be more lightweight than the `init` component. Using multiple components was a decision that was made because using only one component requires script reruns in order to pass new code to the interpreter. This requires more sophisticated logic to implement and is not as dev-friendly.

### Multiple Interpreters

If you want to use multiple interpreters, you can do so by calling the `init` function multiple times. But this time, they must have different keys. This is necessary because the `run` function uses the key to determine which interpreter to pass the code to. If you don't provide a key, the default key is used for both the `init` and `run` functions.

```python
import streamlit as st
import streamlit_execute as se

# Create two interpreters
response_init1 = se.init(key="interpreter1")
response_init2 = se.init(key="interpreter2")

# Connect all run calls to the interpreters
se.connect()

# Run code in the first interpreter
response_add1 = se.run("5 + 5", target_key="interpreter1")
st.write(response_add1)

# Run code in the second interpreter
response_add2 = se.run("a=2\na", target_key="interpreter2")
st.write(response_add2)
```