Let's try to do the same thing in Python as we did in Ruby.
Frontend changes
We can reuse the frontend we just did. The only changes are different code examples in src/App.js
:
let [notebook, updateNotebook] = useImmer([
{ input: "def fib(n):\n if n < 2:\n return 1\n return fib(n-1) + fib(n-2)", output: "" },
{ input: "print([fib(n) for n in range(1,11)])", output: "" },
{ input: "print(3**100)')", output: "" },
])
And different proxy address in package.json
, as flask
default is different to sinatra
default:
"proxy": "http://localhost:5000"
Python Language Server
The server will have same API to the Ruby one, with a single POST /code
endpoint.
#!/usr/bin/env python3
from flask import Flask, request
from io import StringIO
import sys
class Capturing(list):
def __enter__(self):
self._stdout = sys.stdout
self._stderr = sys.stderr
self._stringio = StringIO()
sys.stdout = self._stringio
sys.stderr = self._stringio
return self
def __exit__(self, *args):
output = self._stringio.getvalue()
self.append(output)
sys.stdout = self._stdout
sys.stderr = self._stderr
app = Flask(__name__)
sessions = {}
@app.route("/code", methods=["POST"])
def code():
body = request.json
session_id = body["session_id"]
code = body["code"]
sessions.setdefault(session_id, {})
error = None
with Capturing() as output:
try:
exec(code, sessions[session_id])
except Exception as e:
error = str(e)
return {"output": output[0], "error": error}
There are two things of note here.
First, Python doesn't have blocks, but it has a few close-enough equivalents for some use cases. Capturing
uses StringIO
to capture the output. As Python strings are not modifiable, and with
cannot be used to pass any interesting object, we need to wrap the return value in a one element list. That's why we have to extract it with output[0]
, not just output
. It would be cleaner with blocks but it's good enough.
And second, Python exec
is a bit problematic. In principle it takes three arguments - the code to be executed, globals dictionary, and locals dictionary. Unfortunately if you use it this way, you cannot execute recursive functions. Python would set fib
in locals dictionary, then when it tries to recurse, it would only look inside the globals dictionary. The only workaround is to pass same dictionary as both globals and locals, which conveniently is what already happens if we skip the last argument.
The rest of the code is just a few imports, getting data from JSON request, and a dictionary of sessions.
Running the app
To install the requirements you'll need:
$ pip3 install flask
$ npm install
Then run these in 3 terminals:
$ flask run
$ npm run start
$ npx electron .
Security
And just a reminder, this is literally an HTTP server which by design will execute any code anyone from the same machine sends it, so it's extremely insecure.
Result
Here's the result if we press "Run All" button:
In the next episode we'll try a different approach to communicating with the external programs.
As usual, all the code for the episode is here.
Top comments (0)