isolate 0.26.2__tar.gz → 0.26.4__tar.gz

{isolate-0.26.2/src/isolate.egg-info → isolate-0.26.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isolate
-Version: 0.26.2
+Version: 0.26.4
 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.2 → isolate-0.26.4}/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.2'
-__version_tuple__ = version_tuple = (0, 26, 2)
+__version__ = version = '0.26.4'
+__version_tuple__ = version_tuple = (0, 26, 4)
 
-__commit_id__ = commit_id = 'g7e1de0bc2'
+__commit_id__ = commit_id = 'gce17302a5'

{isolate-0.26.2 → isolate-0.26.4}/src/isolate/connections/_local/_base.py

@@ -188,7 +188,9 @@ class PythonExecutionBase(Generic[ConnectionType]):
         filtered_env = {
             k: v
             for k, v in os.environ.items()
-            if not k.startswith("NOMAD_") or k.startswith("NOMAD_ALLOC_PORT_")
+            if not k.startswith("NOMAD_")
+            or k.startswith("NOMAD_ALLOC_PORT_")
+            or k.startswith("NOMAD_JOB_ID")
         }
 
         return {

{isolate-0.26.2 → isolate-0.26.4}/src/isolate/connections/grpc/agent.py

@@ -196,6 +196,40 @@ def _resolve_entrypoint(entrypoint: str) -> Any:
     return obj
 
 
+def _get_callable_kind(message: Any) -> str | None:
+    """Return the active callable field across recent proto variants."""
+    try:
+        return message.WhichOneof("callable")
+    except ValueError:
+        has_function = _has_field(message, "function")
+        has_entrypoint = _has_field(message, "entrypoint")
+        if has_function:
+            return "function"
+        if has_entrypoint:
+            return "entrypoint"
+        return None
+
+
+def _has_field(message: Any, field_name: str) -> bool:
+    try:
+        return message.HasField(field_name)
+    except ValueError:
+        return False
+
+
+def _get_optional_bool_field(message: Any, field_name: str) -> Optional[bool]:
+    """Read an optional bool field across proto variants.
+
+    Older generated protobuf modules may expose the field without presence
+    tracking. In that case, only ``True`` can be observed distinctly; ``False``
+    is treated like "unset" so legacy fallback behavior is preserved.
+    """
+    try:
+        return getattr(message, field_name) if message.HasField(field_name) else None
+    except ValueError:
+        return True if getattr(message, field_name, False) else None
+
+
 class AgentServicer(definitions.AgentServicer):
     def __init__(self, log_file: TextIO | None = None):
         super().__init__()
@@ -268,7 +302,7 @@ class AgentServicer(definitions.AgentServicer):
 
         # The `callable` oneof enforces at-most-one on the wire; here we
         # only need to reject the "neither set" case.
-        callable_kind = request.WhichOneof("callable")
+        callable_kind = _get_callable_kind(request)
         if callable_kind is None:
             self.abort_with_msg(
                 context,
@@ -329,11 +363,7 @@ class AgentServicer(definitions.AgentServicer):
             extra_args.append(self._run_cache[cache_key])
 
         try:
-            run_on_main_thread = (
-                request.run_on_main_thread
-                if request.HasField("run_on_main_thread")
-                else None
-            )
+            run_on_main_thread = _get_optional_bool_field(request, "run_on_main_thread")
             if has_entrypoint:
                 invocation = await self.execute_entrypoint(
                     request.entrypoint,

{isolate-0.26.2 → isolate-0.26.4}/src/isolate/server/server.py

@@ -69,6 +69,40 @@ class GRPCException(Exception):
         return f"{self.code.name}: {self.message}"
 
 
+def _get_callable_kind(message: Any) -> str | None:
+    """Return the active callable field across recent proto variants."""
+    try:
+        return message.WhichOneof("callable")
+    except ValueError:
+        has_function = _has_field(message, "function")
+        has_entrypoint = _has_field(message, "entrypoint")
+        if has_function:
+            return "function"
+        if has_entrypoint:
+            return "entrypoint"
+        return None
+
+
+def _has_field(message: Any, field_name: str) -> bool:
+    try:
+        return message.HasField(field_name)
+    except ValueError:
+        return False
+
+
+def _get_optional_bool_field(message: Any, field_name: str) -> bool | None:
+    """Read an optional bool field across proto variants.
+
+    Older generated protobuf modules may expose the field without presence
+    tracking. In that case, only ``True`` can be observed distinctly; ``False``
+    is treated like "unset" so legacy fallback behavior is preserved.
+    """
+    try:
+        return getattr(message, field_name) if message.HasField(field_name) else None
+    except ValueError:
+        return True if getattr(message, field_name, False) else None
+
+
 @dataclass
 class RunnerAgent:
     stub: definitions.AgentStub
@@ -250,7 +284,7 @@ class IsolateServicer(definitions.IsolateServicer):
 
         # The `callable` oneof enforces at-most-one on the wire; here we
         # only need to reject the "neither set" case.
-        callable_kind = task.request.WhichOneof("callable")
+        callable_kind = _get_callable_kind(task.request)
         if callable_kind is None:
             raise GRPCException(
                 "One of 'function' or 'entrypoint' must be set.",
@@ -338,8 +372,11 @@ class IsolateServicer(definitions.IsolateServicer):
                     )
                     if not task.request.HasField("setup_func"):
                         function_call.ClearField("setup_func")
-                if task.request.HasField("run_on_main_thread"):
-                    function_call.run_on_main_thread = task.request.run_on_main_thread
+                run_on_main_thread = _get_optional_bool_field(
+                    task.request, "run_on_main_thread"
+                )
+                if run_on_main_thread is not None:
+                    function_call.run_on_main_thread = run_on_main_thread
 
                 future = local_pool.submit(
                     _proxy_to_queue,

{isolate-0.26.2 → isolate-0.26.4/src/isolate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isolate
-Version: 0.26.2
+Version: 0.26.4
 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.2 → isolate-0.26.4}/tests/test_server.py

@@ -139,6 +139,42 @@ def define_environment(kind: str, **kwargs: Any) -> definitions.EnvironmentDefin
 _NOT_SET = object()
 
 
+class LegacyCallableProto:
+    """Simulate the pre-oneof / pre-optional-bool generated protobuf API."""
+
+    def __init__(
+        self,
+        *,
+        function: bool = False,
+        entrypoint: bool = False,
+        run_on_main_thread: bool = False,
+        supports_entrypoint: bool = True,
+    ) -> None:
+        self.run_on_main_thread = run_on_main_thread
+        self._has_field = {
+            "function": function,
+            "entrypoint": entrypoint,
+        }
+        self._supports_entrypoint = supports_entrypoint
+
+    def WhichOneof(self, name: str) -> Optional[str]:
+        raise ValueError(f'Protocol message FunctionCall has no "{name}" field.')
+
+    def HasField(self, name: str) -> bool:
+        if name == "run_on_main_thread":
+            raise ValueError(
+                "Field FunctionCall.run_on_main_thread does not have presence."
+            )
+        if name == "entrypoint" and not self._supports_entrypoint:
+            raise ValueError('Protocol message FunctionCall has no "entrypoint" field.')
+        try:
+            return self._has_field[name]
+        except KeyError as exc:
+            raise ValueError(
+                f'Protocol message FunctionCall has no "{name}" field.'
+            ) from exc
+
+
 def run_request(
     stub: definitions.IsolateStub,
     request: definitions.BoundFunction,
@@ -417,6 +453,54 @@ def test_agent_import_falls_back_when_common_validator_missing(
         importlib.reload(agent_module)
 
 
+@pytest.mark.parametrize(
+    "module_name",
+    [
+        "isolate.connections.grpc.agent",
+        "isolate.server.server",
+    ],
+)
+def test_callable_kind_falls_back_when_proto_has_no_oneof(module_name: str) -> None:
+    module = importlib.import_module(module_name)
+
+    assert module._get_callable_kind(LegacyCallableProto(function=True)) == "function"
+    assert (
+        module._get_callable_kind(
+            LegacyCallableProto(function=True, supports_entrypoint=False)
+        )
+        == "function"
+    )
+    assert (
+        module._get_callable_kind(LegacyCallableProto(entrypoint=True)) == "entrypoint"
+    )
+    assert module._get_callable_kind(LegacyCallableProto()) is None
+
+
+@pytest.mark.parametrize(
+    "module_name",
+    [
+        "isolate.connections.grpc.agent",
+        "isolate.server.server",
+    ],
+)
+def test_optional_bool_field_falls_back_when_proto_has_no_presence(
+    module_name: str,
+) -> None:
+    module = importlib.import_module(module_name)
+
+    assert (
+        module._get_optional_bool_field(
+            LegacyCallableProto(run_on_main_thread=False),
+            "run_on_main_thread",
+        )
+        is None
+    )
+    assert module._get_optional_bool_field(
+        LegacyCallableProto(run_on_main_thread=True),
+        "run_on_main_thread",
+    )
+
+
 def test_server_entrypoint_module_not_found(
     stub: definitions.IsolateStub, monkeypatch: Any
 ) -> None: