from js import Response

async def on_fetch(request, env):
    return Response.new("Hello world!")

name = "hello-world-python-worker"
main = "src/entry.py"
compatibility_date = "2024-03-18"
compatibility_flags = ["python_workers"]

1. Determine which version of Pyodide is required, based on your compatibility date
2. Create an isolate for your Worker, and automatically inject Pyodide
3. Serve your Python code using Pyodide

How Pyodide works

1. wasm32-unknown-unknown – this backend provides no C standard library or system call interface; to support this backend, we would need to manually rewrite every system or library call to make use of imports we would define ourselves in the runtime.
2. wasm32-wasi – WASI is a standardized system interface, and defines a standard set of imports that are implemented in WASI runtimes such as wasmtime.
3. wasm32-unknown-emscripten – Like WASI, Emscripten defines the imports that a WebAssembly program needs to execute, but also outputs an accompanying JavaScript library that implements these imported functions.

1. A distribution of the CPython interpreter, compiled using Emscripten
2. A foreign function interface (FFI) between Python and JavaScript
3. A set of third-party Python packages, compiled using Emscripten’s compiler to WebAssembly.

from js import Response

async def on_fetch(request, env):
    return Response.new("Hello world!")

from js import JSON

js_array = JSON.parse("[1,2,3]")

for entry in js_array:
   print(entry)

Async Client libraries

from js import Headers, Request, fetch

def py_request_to_js_request(py_request):
    js_headers = Headers.new(py_request.headers)
    return Request.new(py_request.url, method=py_request.method, headers=js_headers)

def js_response_to_py_response(js_response):
  ... # omitted

async def do_request(py_request):
  js_request = py_request_to_js_request(py_request)
    js_response = await fetch(js_request)
    py_response = js_response_to_py_response(js_response)
    return py_response

Synchronous Client libraries

1. Checking if blocking with Atomics.wait() is possible
   a. If so, start a fetch worker thread
   b. Delegate the fetch operation to the worker thread and serialize the response into a SharedArrayBuffer
   c. In the Python thread, use Atomics.wait to block for the response in the SharedArrayBuffer
2. If Atomics.wait() doesn’t work, fall back to a synchronous XMLHttpRequest

WebAssembly Stack Switching

from pyodide.ffi import run_sync

def sync_fetch(py_request):
   js_request = py_request_to_js_request(py_request)
   js_response  = run_sync(fetch(js_request))
   return js_response_to_py_response(js_response)

FastAPI and Python’s Asynchronous Server Gateway Interface

1. Wrangler uploads your Python code and your requirements.txt file to the Workers API
2. We send your Python code, and your requirements.txt file to the Workers runtime to be validated
3. We create a new isolate for your Worker, and automatically inject Pyodide plus any packages you’ve specified in your requirements.txt file.
4. We scan the Worker’s code for import statements, execute them, and then take a snapshot of the Worker’s WebAssembly linear memory. Effectively, we perform the expensive work of importing packages at deploy time, rather than at runtime.
5. We deploy this snapshot alongside your Worker’s Python code to Cloudflare’s network.
6. Just like a JavaScript Worker, we execute the Worker’s top-level scope.

Reusing Memory Snapshots

from js import Response

async def on_fetch(request, env):
    await env.FOO.put("bar", "baz")
    bar = await env.FOO.get("bar")
    return Response.new(bar) # returns "baz"