code-sandboxes 1.4.4__tar.gz → 1.4.5__tar.gz

{code_sandboxes-1.4.4 → code_sandboxes-1.4.5}/CHANGELOG.md

@@ -8,6 +8,24 @@
 
 ## Unreleased
 
+- A Datalayer sandbox says when it is running code, so an interrupt can reach
+  it. `Sandbox.interrupt` refuses before it delegates — `if not
+  self._executing_event.is_set(): return False` — and `run_code` never set that
+  event, so `is_executing` was always False, every interrupt was refused at the
+  door, and the refusal was reported as "no code was running" to a caller
+  watching a cell run.
+
+  This is the other half of the interrupt fix released in 1.4.4, and the
+  measurement said so: with `_do_interrupt` implemented and deployed, cancelling
+  a two-minute cell ten seconds in still left the kernel busy for **60.5
+  seconds**. Implementing the interrupt changed nothing while nothing could call
+  it. Both are needed, and the package's tests now hold them together.
+
+  Five variants — cloudflare, coreweave, daytona, e2b, modal — implement
+  `_do_interrupt` and never mark execution either, so their interrupts are
+  unreachable in the same way. Pinned as known rather than fixed blind, since
+  none can be measured from here.
+
 - `DatalayerSandbox` can be interrupted. It neither implemented `_do_interrupt`
   nor read the flag the base class sets, so the default ran instead: it sets a
   flag, returns `True`, and stops nothing. Everything above believed it —

{code_sandboxes-1.4.4 → code_sandboxes-1.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code_sandboxes
-Version: 1.4.4
+Version: 1.4.5
 Project-URL: Home, https://github.com/datalayer/code-sandboxes
 Author-email: Datalayer <info@datalayer.io>
 License: BSD 3-Clause License

{code_sandboxes-1.4.4 → code_sandboxes-1.4.5}/code_sandboxes/__version__.py

@@ -3,4 +3,4 @@
 
 """Code Sandboxes."""
 
-__version__ = "1.4.4"
+__version__ = "1.4.5"

{code_sandboxes-1.4.4 → code_sandboxes-1.4.5}/code_sandboxes/datalayer_sandbox.py

@@ -801,14 +801,23 @@ class DatalayerSandbox(Sandbox):
 
         started_at = time.time()
 
-        # Set environment variables if provided
-        if envs:
-            env_code = "\n".join(f"import os; os.environ[{k!r}] = {v!r}" for k, v in envs.items())
-            self._runtime.execute(env_code)
-
-        # Execute the code
+        # **Say that code is running, because `interrupt()` will not act
+        # unless it can see that.** `Sandbox.interrupt` returns `False`
+        # before reaching `_do_interrupt` when `_executing_event` is clear,
+        # and this variant never set it — so `is_executing` was always False,
+        # every interrupt was refused at the door, and the refusal was
+        # reported as "no code was running" to a caller watching a cell run.
+        # Implementing `_do_interrupt` alone did not fix cancellation for
+        # exactly this reason: nothing ever called it.
         execution_timeout = timeout or self.config.timeout
+        self._interrupt_requested.clear()
+        self._executing_event.set()
         try:
+            # Set environment variables if provided
+            if envs:
+                env_code = "\n".join(f"import os; os.environ[{k!r}] = {v!r}" for k, v in envs.items())
+                self._runtime.execute(env_code)
+
             response = self._runtime.execute(code, timeout=execution_timeout)
         except Exception as e:
             # Infrastructure failure - couldn't execute the code
@@ -822,6 +831,8 @@ class DatalayerSandbox(Sandbox):
                 started_at=started_at,
                 completed_at=time.time(),
             )
+        finally:
+            self._executing_event.clear()
 
         # Parse the response
         stdout_messages: list[OutputMessage] = []

{code_sandboxes-1.4.4 → code_sandboxes-1.4.5}/tests/test_a_datalayer_sandbox_can_be_interrupted.py

@@ -160,3 +160,97 @@ class TestTheChainReachesAKernel:
         from code_sandboxes.jupyter_server_sandbox import JupyterServerSandbox
 
         assert "_do_interrupt" in JupyterServerSandbox.__dict__
+
+class TestTheInterruptIsReached:
+    """`_do_interrupt` was necessary and not sufficient, which the first
+    measurement after deploying it said plainly: still 60.5 seconds.
+
+    `Sandbox.interrupt` refuses before it delegates::
+
+        if not self._executing_event.is_set():
+            return False
+        self._interrupt_requested.set()
+        return self._do_interrupt()
+
+    `DatalayerSandbox.run_code` never set that event, so `is_executing` was
+    always False and every interrupt was refused at the door — and reported
+    as "no code was running" to a caller watching a cell run. Two guards,
+    both needed: one that the door opens, one that what is behind it works.
+    """
+
+    def test_run_code_says_that_code_is_running(self):
+        import threading
+
+        from code_sandboxes.datalayer_sandbox import DatalayerSandbox
+
+        seen = []
+
+        class _Runtime:
+            sandbox_client = None
+
+            def execute(self, code, timeout=None):
+                seen.append(sandbox._executing_event.is_set())
+                raise RuntimeError("stop here; the flag is what is under test")
+
+        sandbox = DatalayerSandbox.__new__(DatalayerSandbox)
+        sandbox._started = True
+        sandbox._runtime = _Runtime()
+        sandbox._executing_event = threading.Event()
+        sandbox._interrupt_requested = threading.Event()
+        sandbox._connect = lambda: None
+        sandbox._sandbox_id = "sb_test"
+
+        class _Config:
+            timeout = 30
+
+        sandbox.config = _Config()
+        sandbox.run_code("print(1)")
+
+        assert seen == [True], "the sandbox ran code without saying it was running"
+        assert not sandbox._executing_event.is_set(), "the flag outlived the execution"
+
+    def test_every_variant_that_can_be_interrupted_says_when_it_runs(self):
+        """The pair, held together: implementing `_do_interrupt` while never
+        setting the event is a fix that changes nothing, and that is the
+        mistake this file exists to stop repeating."""
+        import importlib
+        import inspect
+        import pkgutil
+
+        import code_sandboxes
+        from code_sandboxes.base import Sandbox
+
+        mute = set()
+        for module in pkgutil.iter_modules(code_sandboxes.__path__):
+            if not module.name.endswith("_sandbox"):
+                continue
+            loaded = importlib.import_module(f"code_sandboxes.{module.name}")
+            source = inspect.getsource(loaded)
+            for name in dir(loaded):
+                value = getattr(loaded, name)
+                if (
+                    isinstance(value, type)
+                    and issubclass(value, Sandbox)
+                    and value is not Sandbox
+                    and value.__module__ == loaded.__name__
+                    and "_do_interrupt" in value.__dict__
+                    and "_executing_event.set()" not in source
+                ):
+                    mute.add(f"{module.name}.{name}")
+
+        # Not exemptions — the same unreachable interrupt, pinned. The gate in
+        # `Sandbox.interrupt` is held for every variant, so these five ask a
+        # provider to stop work and are refused before they can: each one has
+        # a written interrupt that nothing can call. Left as found rather than
+        # fixed blind, because none of them can be measured from here.
+        known = {
+            "cloudflare_sandbox.CloudflareSandbox",
+            "coreweave_sandbox.CoreWeaveSandbox",
+            "daytona_sandbox.DaytonaSandbox",
+            "e2b_sandbox.E2BSandbox",
+            "modal_sandbox.ModalSandbox",
+        }
+        assert mute - known == set(), (
+            f"these implement an interrupt nothing can reach: {mute - known}"
+        )
+        assert known - mute == set(), f"reachable now — drop from the pinned set: {known - mute}"