Blocking PyScript execution lacks uniform timeout semantics across worker and main-thread modes

Answer to the core question

For long‑running tasks that may block the UI, the <py-worker> or worker attribute on <py-script> is the most predictable execution model. It guarantees that the main thread remains responsive and that cancellation logic can be implemented inside the Python code using asyncio. PyScript does not yet expose a tag‑level timeout attribute that works uniformly across both Pyodide and MicroPython; interruption is therefore entirely cooperative and only takes effect at await points.

Why worker‑based execution wins

• Runs in a separate Web Worker, so the browser’s rendering loop is never blocked by synchronous Python loops.
• Pyodide’s Pyodide.runPythonAsync and MicroPython’s worker entry point both allow the Python code to yield control when it reaches an await or an explicit await asyncio.sleep(0).
• Both runtimes support asyncio.wait_for and Task.cancel for I/O‑bound coroutines, giving a consistent cancellation pattern.
• CPU‑bound synchronous loops cannot be preempted by any external timeout; the only mitigation is to move them into a worker and structure them as async tasks that periodically yield.

Confirmed facts (as of PyScript 0.14.x)

• No documented timeout attribute exists on <py-script> or <py-worker> that terminates a task automatically.
• Pyodide’s asyncio.wait_for works for I/O‑bound coroutines but does not preempt synchronous loops.
• MicroPython’s standard library is smaller; asyncio.wait_for is available but may behave differently or be absent in older builds.
• Both runtimes expose an interrupt buffer only for Pyodide, not for MicroPython, so it cannot be used for cross‑runtime cancellation.

Practical steps to ensure uniform behavior

1. Choose the worker mode:

   <py-script worker>
       # Python code here
   </py-script>

   or

   <py-worker>
       # Python code here
   </py-worker>

2. Wrap I/O operations in asyncio.wait_for:

   import asyncio
   async def fetch(url):
       return await asyncio.wait_for(asyncio.to_thread(http_get, url), timeout=5)
   

3. Cancel at await points:

   task = asyncio.create_task(fetch("https://example.com"))
   # Later, to cancel:
   task.cancel()
   

4. Test both runtimes:

   # In an HTML page, load both Pyodide and MicroPython builds.
   # Run the same coroutine under each and verify that cancellation only occurs after an await.
   

5. Verify UI responsiveness:

   # If the page remains interactive during the task, the worker is functioning correctly.
   # A frozen UI indicates the code ran on the main thread.
   

What to ask for to refine recommendations

Does your deployment use a PyScript version newer than 0.14.x, or have you enabled any experimental runtime features that might introduce a timeout attribute? Knowing the exact release will determine whether future releases may provide a built‑in timeout.

Conclusion

Until PyScript introduces a documented, cross‑runtime timeout API, developers should rely on worker execution and cooperative asyncio cancellation. This approach guarantees UI responsiveness and predictable interruption semantics across both Pyodide and MicroPython.