isolate 0.26.5__tar.gz → 0.26.7__tar.gz

{isolate-0.26.5 → isolate-0.26.7}/.github/workflows/test.yml

@@ -22,12 +22,12 @@ jobs:
 
       matrix:
         os: [ubuntu-latest]
-        python: ["3.8", "3.9", "3.10", "3.11"]
+        python: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
         include:
           - os: macos-15-intel
             python: "3.8"
           - os: macos-15-intel
-            python: "3.11"
+            python: "3.14"
     steps:
       - uses: actions/checkout@v3
 

{isolate-0.26.5/src/isolate.egg-info → isolate-0.26.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isolate
-Version: 0.26.5
+Version: 0.26.7
 Summary: Managed isolated environments for Python
 Author-email: Features & Labels <hello@fal.ai>
 Project-URL: Issues, https://github.com/fal-ai/isolate/issues

{isolate-0.26.5 → isolate-0.26.7}/pyproject.toml

@@ -76,3 +76,8 @@ keep-runtime-typing = true
 
 [tool.ruff.lint]
 select = ["E", "F", "W", "PLC", "PLE", "PLW", "I", "UP"]
+
+[tool.pytest.ini_options]
+addopts = "-ra --durations=50"
+asyncio_mode = "auto"
+testpaths = "tests"

{isolate-0.26.5 → isolate-0.26.7}/src/isolate/_isolate_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.26.5'
-__version_tuple__ = version_tuple = (0, 26, 5)
+__version__ = version = '0.26.7'
+__version_tuple__ = version_tuple = (0, 26, 7)
 
-__commit_id__ = commit_id = 'g597c919ae'
+__commit_id__ = commit_id = 'g9b3604b86'

{isolate-0.26.5 → isolate-0.26.7}/src/isolate/backends/common.py

@@ -166,13 +166,15 @@ def _close_fd(fd: int) -> None:
 
 
 def _unblocked_pipe() -> tuple[int, int]:
-    """Create a pair of unblocked pipes. This is actually
-    the same as os.pipe2(os.O_NONBLOCK), but that is not
-    available in MacOS so we have to do it manually."""
+    """Create a pipe whose read end is non-blocking, so the reader thread in
+    `_io_observer` can `select()` + `read()` without risk of hanging on a
+    partial-line edge case. The write end stays blocking so the worker's
+    stdout/stderr applies backpressure (waits for the reader to drain the
+    kernel pipe buffer) instead of raising BlockingIOError when the buffer
+    fills up — which happens reliably with chunky tracebacks on Python 3.14."""
 
     read_fd, write_fd = os.pipe()
     os.set_blocking(read_fd, False)
-    os.set_blocking(write_fd, False)
     return read_fd, write_fd
 
 

{isolate-0.26.5 → isolate-0.26.7}/src/isolate/connections/common.py

@@ -4,6 +4,7 @@ import importlib
 import os
 from contextlib import contextmanager
 from dataclasses import dataclass
+from types import TracebackType
 from typing import TYPE_CHECKING, Any, Iterator, cast
 
 from tblib import Traceback, TracebackParseError
@@ -28,6 +29,14 @@ class SerializationError(Exception):
     message: str
 
 
+@dataclass
+class ExceptionDeserializationError(SerializationError):
+    """Raised when a remote exception cannot be deserialized locally (e.g. the
+    module that defines its type isn't importable here)."""
+
+    original_traceback: TracebackType | None
+
+
 # NOTE: tblib's install() will search for BaseException subclasses,
 # so we have to call it after the SerializationError is defined.
 tblib_install()
@@ -77,8 +86,19 @@ def load_serialized_object(
             importlib.import_module(serialization_method)
         )
 
-    with _step("deserializing the given object"):
-        result = serialization_backend.loads(raw_object)
+    try:
+        with _step("deserializing the given object"):
+            result = serialization_backend.loads(raw_object)
+    except SerializationError as exc:
+        if was_it_raised:
+            # We were trying to reconstruct a remote exception but its type
+            # isn't importable here, so loads() failed. Surface the genuine
+            # local cause along with the remote traceback.
+            raise ExceptionDeserializationError(
+                exc.message,
+                original_traceback=_prepare_traceback(stringized_traceback),
+            ) from exc.__cause__
+        raise
 
     if was_it_raised:
         raise prepare_exc(result, stringized_traceback=stringized_traceback)
@@ -111,18 +131,19 @@ def validate_entrypoint(entrypoint: str) -> None:
         raise ValueError(f"Invalid entrypoint {entrypoint!r}: expected 'module:attr'.")
 
 
+def _prepare_traceback(stringized_traceback: str | None) -> TracebackType | None:
+    if stringized_traceback:
+        try:
+            return Traceback.from_string(stringized_traceback).as_traceback()
+        except TracebackParseError:
+            pass
+    return None
+
+
 def prepare_exc(
     exc: BaseException,
     *,
     stringized_traceback: str | None = None,
 ) -> BaseException:
-    if stringized_traceback:
-        try:
-            traceback = Traceback.from_string(stringized_traceback).as_traceback()
-        except TracebackParseError:
-            traceback = None
-    else:
-        traceback = None
-
-    exc.__traceback__ = traceback
+    exc.__traceback__ = _prepare_traceback(stringized_traceback)
     return exc

{isolate-0.26.5 → isolate-0.26.7/src/isolate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isolate
-Version: 0.26.5
+Version: 0.26.7
 Summary: Managed isolated environments for Python
 Author-email: Features & Labels <hello@fal.ai>
 Project-URL: Issues, https://github.com/fal-ai/isolate/issues

{isolate-0.26.5 → isolate-0.26.7}/src/isolate.egg-info/SOURCES.txt

@@ -79,6 +79,7 @@ tests/test_connections_grpc_base.py
 tests/test_isolate.py
 tests/test_log.py
 tests/test_log_masking.py
+tests/test_logged_io_pipe.py
 tests/test_logger.py
 tests/test_serialization.py
 tests/test_server.py

{isolate-0.26.5 → isolate-0.26.7}/tests/test_backends.py

@@ -555,6 +555,7 @@ class TestConda(GenericEnvironmentTests):
             "packages": [],
         },
         "black": {
+            "python_version": "3.11",
             "packages": ["black=22.12.0"],
         },
         "old-python": {

isolate-0.26.7/tests/test_logged_io_pipe.py

@@ -0,0 +1,132 @@
+"""Regression tests for the pipe wiring used by `logged_io`.
+
+Background: `_unblocked_pipe()` is consumed by `logged_io()`, where the
+*read* end is drained from a reader thread (`_io_observer`) using
+`select()` + `os.read()`. Only the read end needs to be non-blocking
+(so the post-`select` read can never hang on a partial-line edge case).
+
+Historically both ends were marked non-blocking. That makes the *write*
+end raise `BlockingIOError` (errno EAGAIN) the moment the kernel pipe
+buffer (~64 KB on Linux) fills up before the reader thread drains it —
+which is exactly what happens when a worker emits a chunky traceback.
+With a blocking write end, writers apply backpressure instead.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import threading
+
+import pytest
+from isolate.backends.common import _unblocked_pipe, logged_io
+
+
+def test_unblocked_pipe_write_end_is_blocking():
+    """The write end must be blocking so that worker stdout/stderr applies
+    backpressure instead of raising BlockingIOError when the pipe buffer fills."""
+    read_fd, write_fd = _unblocked_pipe()
+    try:
+        assert not os.get_blocking(read_fd), "read end must be non-blocking"
+        assert os.get_blocking(write_fd), (
+            "write end must be blocking so the worker gets backpressure "
+            "instead of BlockingIOError when the pipe buffer fills up"
+        )
+    finally:
+        os.close(read_fd)
+        os.close(write_fd)
+
+
+def test_writing_more_than_pipe_buffer_does_not_raise_blocking_io_error():
+    """Direct reproducer: write more than the kernel pipe buffer (64 KB on
+    Linux) through a Python BufferedWriter on top of the pipe's write end,
+    while a reader thread drains it slowly. With a non-blocking write end
+    this raises `BlockingIOError`; with a blocking write end the writer
+    transparently waits for the reader to make room.
+    """
+    read_fd, write_fd = _unblocked_pipe()
+    drained = bytearray()
+    drain_done = threading.Event()
+
+    def drain():
+        # Slow reader: read in small chunks with a `select` loop, mimicking
+        # `_io_observer`'s pattern but slower so the pipe buffer fills up.
+        import select as _select
+
+        while not drain_done.is_set():
+            ready, _, _ = _select.select([read_fd], [], [], 0.05)
+            if read_fd in ready:
+                try:
+                    chunk = os.read(read_fd, 4096)
+                except BlockingIOError:
+                    continue
+                if not chunk:
+                    return
+                drained.extend(chunk)
+
+    reader = threading.Thread(target=drain)
+    reader.start()
+    try:
+        # 512 KB is well past the 64 KB pipe buffer on Linux.
+        payload = b"x" * (512 * 1024)
+        with open(write_fd, "wb", closefd=False) as stream:
+            stream.write(payload)
+            stream.flush()
+        # Give the reader a moment to catch up.
+        deadline_loops = 50
+        while len(drained) < len(payload) and deadline_loops > 0:
+            deadline_loops -= 1
+            drain_done.wait(0.05)
+    finally:
+        drain_done.set()
+        os.close(write_fd)
+        reader.join(timeout=2)
+        os.close(read_fd)
+
+    assert len(drained) == len(
+        payload
+    ), f"reader only drained {len(drained)} of {len(payload)} bytes"
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="pipes / pass_fds are POSIX-y")
+def test_logged_io_subprocess_emitting_large_output_does_not_crash():
+    """End-to-end reproducer mirroring how `logged_io` is used in
+    `isolate.connections._local._base`: a child process writes a chunky
+    payload (~256 KB) to stdout. With a non-blocking write end the child's
+    Python runtime raises `BlockingIOError` when flushing stdout; with
+    backpressure the child completes cleanly and the parent receives
+    every line."""
+
+    captured: list[str] = []
+    lock = threading.Lock()
+
+    def record(line: str) -> None:
+        with lock:
+            captured.append(line)
+
+    n_lines = 4000
+    line_template = "trace-{idx:08d}-" + ("y" * 50)
+    child_script = (
+        "import sys\n"
+        f"for i in range({n_lines}):\n"
+        f"    sys.stdout.write({line_template!r}.format(idx=i) + '\\n')\n"
+        "sys.stdout.flush()\n"
+    )
+
+    with logged_io(record) as (stdout, stderr, log_fd):
+        proc = subprocess.run(
+            [sys.executable, "-u", "-c", child_script],
+            stdout=stdout,
+            stderr=stderr,
+            pass_fds=(log_fd,),
+            text=True,
+            check=False,
+        )
+
+    assert proc.returncode == 0, (
+        f"child exited with {proc.returncode}; with a non-blocking write end "
+        "Python's stdout buffer raises BlockingIOError on large flushes"
+    )
+    # All `n_lines` should have been captured by the observer thread.
+    assert len(captured) == n_lines, f"expected {n_lines} lines, got {len(captured)}"

{isolate-0.26.5 → isolate-0.26.7}/tests/test_serialization.py

@@ -1,7 +1,11 @@
+import importlib
+import sys
+import traceback
 from functools import partial
 
 import pytest
 from isolate.connections.common import (
+    ExceptionDeserializationError,
     SerializationError,
     load_serialized_object,
     serialize_object,
@@ -37,6 +41,38 @@ def test_deserialize_raised_exception():
     assert exc_info.value.args == ("some error",)
 
 
+def test_deserialize_raised_exception_with_unimportable_type_preserves_traceback(
+    tmp_path,
+    monkeypatch,
+):
+    module_name = "remote_only_exc_for_isolate_test"
+    module_path = tmp_path / f"{module_name}.py"
+    module_path.write_text("class RemoteOnlyError(Exception):\n    pass\n")
+    monkeypatch.syspath_prepend(str(tmp_path))
+    remote_module = importlib.import_module(module_name)
+
+    try:
+        raise remote_module.RemoteOnlyError("remote boom")
+    except remote_module.RemoteOnlyError as exc:
+        serialized = serialize_object("pickle", exc)
+        stringized_traceback = traceback.format_exc()
+
+    sys.modules.pop(module_name, None)
+    sys.path.remove(str(tmp_path))
+
+    with pytest.raises(ExceptionDeserializationError) as exc_info:
+        load_serialized_object(
+            "pickle",
+            serialized,
+            was_it_raised=True,
+            stringized_traceback=stringized_traceback,
+        )
+
+    assert exc_info.value.message == "Error while deserializing the given object"
+    assert exc_info.value.original_traceback is not None
+    assert isinstance(exc_info.value.__cause__, ModuleNotFoundError)
+
+
 def error_while_serializing():
     anon = lambda: 2 + 2  # anonymous functions are not  # noqa: E731
     # serializable by pickle