dagflows 0.2.2__tar.gz → 0.2.3__tar.gz

{dagflows-0.2.2 → dagflows-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dagflows
-Version: 0.2.2
+Version: 0.2.3
 Summary: SDK for authoring and running Dagflows workflows
 Project-URL: Homepage, https://github.com/dagflows/sdk-python
 Project-URL: Repository, https://github.com/dagflows/sdk-python

{dagflows-0.2.2 → dagflows-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dagflows"
-version = "0.2.2"
+version = "0.2.3"
 description = "SDK for authoring and running Dagflows workflows"
 readme = "README.md"
 requires-python = ">=3.11"

dagflows-0.2.3/src/dagflows/_runtime/ready.py

@@ -0,0 +1,38 @@
+"""
+Ready signal: tells the guest agent the runtime has finished starting.
+"""
+
+from __future__ import annotations
+
+import os
+
+# Descriptor the guest agent listens on for the runtime's ready signal.
+READY_FD_ENV = "DAGFLOWS_READY_FD"
+
+
+def signal_ready() -> None:
+    """Notify the guest agent that runtime initialization is complete and the handler is starting.
+
+    The node's execution timeout begins counting from this signal, ensuring that
+    interpreter startup and module imports do not consume the user's execution budget.
+
+    The signal dynamically tightens the execution deadline. If never sent, the agent
+    terminates the process at the hard ceiling (init allowance + timeout).
+
+    This function is idempotent and safe to call multiple times. If the ready file
+    descriptor is unset or unavailable, it silently no-ops.
+    """
+    try:
+        fd = int(os.environ.get(READY_FD_ENV, ""))
+    except ValueError:
+        return
+
+    if fd <= 0:
+        return
+
+    try:
+        os.write(fd, b".")
+    except OSError:
+        # The descriptor is the platform's to provide. A node cannot do
+        # anything about a broken one, and only its own deadline is affected.
+        pass

{dagflows-0.2.2 → dagflows-0.2.3}/src/dagflows/_runtime/runner.py

@@ -14,6 +14,7 @@ from typing import Any
 from . import binding
 from .envelope import OUTPUT_ENV, Ctx, Inputs, load
 from .errors import Fail
+from .ready import signal_ready
 from .result import Upload, to_envelope
 
 Handler = Callable[..., Any]
@@ -102,6 +103,10 @@ def run(handler: Handler) -> None:
     ctx, inputs = load()
 
     try:
+        # The handler starts here, so this is where the node's timeout should
+        # begin being charged. Everything above was the runtime starting up.
+        signal_ready()
+
         answer = _call(handler, ctx, inputs)
         envelope = to_envelope(
             answer,

dagflows-0.2.3/tests/test_ready.py

@@ -0,0 +1,67 @@
+"""The ready signal that starts a node's timeout at its handler."""
+
+import json
+import os
+
+import pytest
+
+import dagflows
+from dagflows._runtime.ready import READY_FD_ENV, signal_ready
+
+
+@pytest.fixture
+def ready_file(tmp_path, monkeypatch):
+    """Point the ready descriptor at a file and report what the signal wrote."""
+    path = tmp_path / "signal"
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT)
+    monkeypatch.setenv(READY_FD_ENV, str(fd))
+
+    try:
+        yield path
+    finally:
+        os.close(fd)
+
+
+def test_it_writes_a_single_byte_to_the_descriptor_the_platform_names(ready_file):
+    signal_ready()
+
+    assert ready_file.read_bytes() == b"."
+
+
+def test_it_does_nothing_when_no_descriptor_is_named(monkeypatch):
+    monkeypatch.delenv(READY_FD_ENV, raising=False)
+
+    # An older worker passes no descriptor. The node still runs; it just spends
+    # its own timeout on startup, as it did before.
+    signal_ready()
+
+
+@pytest.mark.parametrize("value", ["", "0", "-1", "not-a-number", "9999"])
+def test_it_does_nothing_when_the_descriptor_is_unusable(monkeypatch, value):
+    monkeypatch.setenv(READY_FD_ENV, value)
+
+    signal_ready()
+
+
+def test_run_signals_ready_before_the_handler_runs_not_after(tmp_path, monkeypatch, ready_file):
+    """A signal sent after the handler charges startup to the node, so order is the point."""
+    envelope = {"ctx": {"node_key": "n", "inline_max_bytes": 1 << 20}, "payload": {"inputs": {}}}
+    in_path = tmp_path / "in.json"
+    out_path = tmp_path / "out.json"
+    in_path.write_text(json.dumps(envelope), encoding="utf-8")
+
+    monkeypatch.setenv("DAGFLOWS_INPUT", str(in_path))
+    monkeypatch.setenv("DAGFLOWS_OUTPUT", str(out_path))
+
+    seen = {}
+
+    def handler(ctx, inputs):
+        # Reading the signal file as the handler's first act: a byte here proves
+        # the signal was sent before the handler was entered.
+        seen["at_entry"] = ready_file.read_bytes()
+        return {"ok": True}
+
+    dagflows.run(handler)
+
+    assert seen["at_entry"] == b"."
+    assert json.loads(out_path.read_text(encoding="utf-8"))["status"] == "SUCCESS"

{dagflows-0.2.2 → dagflows-0.2.3}/uv.lock

@@ -35,7 +35,7 @@ wheels = [
 
 [[package]]
 name = "dagflows"
-version = "0.2.2"
+version = "0.2.3"
 source = { editable = "." }
 
 [package.optional-dependencies]