Test Code Remotely with Ratio1 – Build Your Own Sandbox in Minutes

Introduction

Imagine that you can test your code remotely in a secure, decentralized environment. Well, that is not only possible but also incredibly easy with the Ratio1 Protocol. Today, I’m going to show you how to use the web app at sandbox.ratio1.ai, where you can play with code using our ready-made templates or create something from scratch. I’ll also guide you on how to build your own sandbox in just a few steps.

To put that into perspective, here is a screenshot of the web app interface:

Getting Started with sandbox.ratio1.ai

The web app offers users a variety of ready-to-use code templates, making it simple to get started. You can either modify these templates to suit your needs or write your own code from scratch.

Code Example: Fibonacci Sequence Prediction

Here’s an example of a template that calculates the Fibonacci sequence and predicts the next elements:

# First 9 Fibonacci elements
x = [1, 1, 2, 3, 5, 8, 13, 21, 34]

# We predict the next 7 elements using the basic_ts_fit_predict method
yh = plugin.basic_ts_fit_predict(data=x, steps=7)
print(yh)

# Actual next 7 values in the Fibonacci sequence
y = [55, 89, 144, 233, 377, 610, 987]

# Compute the mean absolute error of the prediction
yh_np = plugin.np.array(yh)
y_np = plugin.np.array(y)
result = plugin.np.abs(y_np - yh_np).mean()
print(result)

With just a few lines of code, you can run a predictive analysis and even calculate the error of the prediction.

Safety and Security: What Happens if You Run Harmful Code?

For security reasons some operations are not allowed. For example code which attempts to delete files from the processing node will be rejected as will specific imports such as os. To offer some degree of flexibility, though we have made accessible a range of utility functions via our API – as you saw in the Fibonacci example above. Here is an example of a script which would not pass:

import os
for root, dirs, files in os.walk():
    for file in files:
        os.remove(os.path.join(root, file))

# Alternative blocked method using plugin.os
for root, dirs, files in plugin.os.walk():
    for file in files:
        plugin.os.remove(plugin.os.path.join(root, file))

The system is designed to block such unsafe operations while still providing users with powerful tools to experiment within the sandbox.

Build Your Own Code Sandbox in Minutes

Let’s now walk through how you can quickly deploy your own code sandbox using the PyE2 library. No need to clone a GitHub repository—just follow the simple steps below.

Step-by-Step Guide to Deploying Your Own Sandbox

1. Install the PyE2 Library

   pip install PyE2

2. Connect to the network

Use the PyE2 library to connect to a node and deploy your code execution and interface endpoints:

   from PyE2 import Session
   
   session = Session()

   node = "0xai_AwTD0PEqh_dmW3vH_h8N6CyNwLOh4ql2khy7-yP4Ltp-"
   session.wait_for_node(node)

3. Create your Custom WebApp

After connecting to the node we need to define a WebApp instance:

    pipeline, instance = session.create_web_app(
        node=node,
        name="naeural_code_sandbox_copycat_app",
        signature=CustomWebApp01,

        ngrok_edge_label="edghts_2jSQ4nm5TuzGgHh8I0wlfDz3Vr0",  # your ngrok URL
        use_ngrok=True,
    )

The code above will create a WebApp instance that will be accessible through an Ngrok edge at https://naeural-001.ngrok.app/docs .

4. Define an endpoint

We have the domain, let’s create an endpoint.

   def remote_execute(plugin: CustomPluginTemplate, code: str):
    result = plugin.execute_remote_code(code=code)
    return {
        "Congratulations": "You have successfully executed the code!",
        **result,
    }

This method will receive some code and will attempt to execute it and return the result. We can attach it to the domain created before as follows:

    instance.add_new_endpoint(remote_execute, method="post")

After this it will be accessible at https://naeural-001.ngrok.app/remote_execute .

5. Create our interface

Up until now we successfully wrote a WebAPI on which one can execute code. Now let’s attach an interface to it.

    instance.add_new_html_endpoint(
        html_path=<path to your HTML file>

And just like that, you have got an interface where users can write code.

6. Finally deploy

All is left now is just one line of code to start the magic:

    pipeline.deploy()

Full Example Code

Below is the complete code to deploy your custom sandbox web app:

from PyE2 import CustomPluginTemplate, Session
from PyE2.default.instance import CustomWebApp01

# This tutorial can be run only on the local edge node
# because it uses ngrok to expose the FastAPI server,
# and this requires a ngrok auth token

# See https://naeural-001.ngrok.app/docs

def remote_execute(plugin: CustomPluginTemplate, code: str):
    result = plugin.execute_remote_code(code=code)
    return {
        "Congratulations": "You have successfully executed the code!",
        **result,
    }

if __name__ == "__main__":
    session = Session()

    node = "0xai_AwTD0PEqh_dmW3vH_h8N6CyNwLOh4ql2khy7-yP4Ltp-"
    session.wait_for_node(node)

    instance: CustomWebApp01
    pipeline, instance = session.create_web_app(
        node=node,
        name="naeural_code_sandbox_copycat_app",
        signature=CustomWebApp01,

        ngrok_edge_label="edghts_2jSQ4nm5TuzGgHh8I0wlfDz3Vr0",  # your ngrok URL
        use_ngrok=True,
    )

    # POST request on <domain>/remote_execute (with body as JSON with 1 key: code)
    instance.add_new_endpoint(remote_execute, method="post")

    # Add an HTML file to the web app, accessible at <domain>/
    instance.add_new_html_endpoint(
        html_path=<path to your html file>

Conclusion

Testing code remotely was never easier, and with Ratio1, fast and secure, too. Give the templates available in the sandbox.ratio1.ai a try or create your own sandbox in a few lines of code.

Feel free to give that a shot and share with the community! If you have any questions, go ahead and comment or reach out to us. Happy coding!