commandnet 0.4.2__tar.gz → 0.5.1__tar.gz

{commandnet-0.4.2 → commandnet-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commandnet
-Version: 0.4.2
+Version: 0.5.1
 Summary: A lightweight, Pydantic-powered, distributed event-driven state machine and typed node graph runtime.
 Author: Christopher Vaz
 Author-email: christophervaz160@gmail.com

{commandnet-0.4.2 → commandnet-0.5.1}/commandnet/core/models.py

@@ -11,7 +11,6 @@ class Event(BaseModel):
     subject_id: str
     node_name: str
     payload: Optional[Dict[str, Any]] = None
-    headers: Dict[str, str] = Field(default_factory=dict)
     
     timestamp: str = Field(default_factory=utcnow_iso)
     run_at: str = Field(default_factory=utcnow_iso) 

{commandnet-0.4.2 → commandnet-0.5.1}/commandnet/engine/runtime.py

@@ -70,8 +70,10 @@ class Engine:
 
     async def _run_node_logic(self, event: Event):
         subject_id = event.subject_id
-        # We allow "AWAITING_CALL" because an subject wakes up from that state when a 'Call' resolves
+
+        # 1. READ & LOCK
         node_name, ctx_dict = await self.db.lock_and_load(subject_id)
+
         if not node_name or (
             node_name != event.node_name and node_name != "AWAITING_CALL"
         ):
@@ -92,33 +94,42 @@ class Engine:
                 if hasattr(ctx_type, "model_validate")
                 else ctx_dict
             )
+
             payload = (
                 payload_type.model_validate(event.payload)
                 if (event.payload and hasattr(payload_type, "model_validate"))
                 else event.payload
             )
 
-            # Support Soft-Cancel checking inside Node.run
+            # Soft cancel check BEFORE compute
             if hasattr(ctx, "is_cancelled"):
                 ctx.is_cancelled = await self.db.is_cancelled(subject_id)
 
+            # 2. RELEASE LOCK before long-running compute
+            await self.db.unlock_subject(subject_id)
+
+            # 3. COMPUTE (no DB lock held)
             start_t = asyncio.get_event_loop().time()
             result = await node_cls().run(ctx, payload)
+            duration = (asyncio.get_event_loop().time() - start_t) * 1000
+
+            # 4. RE-LOCK before writing
+            node_name_check, _ = await self.db.lock_and_load(subject_id)
+
+            # 🔴 IMPORTANT SAFETY CHECK (prevents stale writes)
+            if node_name_check != event.node_name and node_name_check != "AWAITING_CALL":
+                await self.db.unlock_subject(subject_id)
+                return
+
+            await self._apply_target(subject_id, ctx, result, duration)
 
-            await self._apply_target(
-                subject_id,
-                ctx,
-                result,
-                (asyncio.get_event_loop().time() - start_t) * 1000,
-            )
         except Exception as e:
             await self.observer.on_error(subject_id, event.node_name, e)
             raise
         finally:
+            # Ensure we never leave a lock hanging
             await self.db.unlock_subject(subject_id)
 
-    # --- RECURSIVE TARGET RESOLVER ---
-
     async def _apply_target(
         self,
         subject_id: str,
@@ -127,9 +138,6 @@ class Engine:
         duration: float = 0.0,
         payload: Any = None,
     ):
-        headers = {}
-        if hasattr(context, "trace_headers") and context.trace_headers:
-            headers = context.trace_headers
         # 1. Interrupt (Cancellation)
         if isinstance(target, Interrupt):
             await self.cancel_subject(target.subject_id, target.hard)
@@ -168,7 +176,6 @@ class Engine:
                 key = subject_id.split("#")[1]
                 waiters = await self.db.resolve_call_group(key)
                 for w in waiters:
-                    # Resume waiters using the final context of the shared node as payload
                     await self._apply_target(
                         w["subject_id"],
                         w["context"],
@@ -194,14 +201,23 @@ class Engine:
             node_name = target.get_node_name()
             await self.observer.on_transition(subject_id, "RUN", node_name, duration)
 
+            # PROPAGATION: Use provided payload
             p_load = payload.model_dump() if hasattr(payload, "model_dump") else payload
 
-            evt = Event(subject_id=subject_id, node_name=node_name, payload=p_load, headers=headers)
+            evt = Event(
+                subject_id=subject_id,
+                node_name=node_name,
+                payload=p_load,
+            )
             ctx_dict = self._dump_ctx(context)
 
             if "#" in subject_id:
                 await self.db.save_sub_state(
-                    subject_id, subject_id.split("#")[0], node_name, ctx_dict, evt
+                    subject_id,
+                    subject_id.split("#")[0],
+                    node_name,
+                    ctx_dict,
+                    evt,
                 )
             else:
                 await self.db.save_state(subject_id, node_name, ctx_dict, evt)
@@ -213,6 +229,7 @@ class Engine:
         if isinstance(target, Wait):
             actual_id = subject_id
             actual_ctx = context
+
             if target.sub_context_path and "#" not in subject_id:
                 actual_id = f"{subject_id}#{target.sub_context_path}"
                 actual_ctx = self._get_path(context, target.sub_context_path)
@@ -220,6 +237,7 @@ class Engine:
             await self.observer.on_transition(
                 actual_id, "RUN", f"WAIT:{target.signal_id}", duration
             )
+
             await self.db.park_subject(
                 actual_id,
                 target.signal_id,
@@ -230,7 +248,12 @@ class Engine:
 
         # 6. Parallel Fan-out
         if isinstance(target, Parallel):
-            join_name = target.join_node.get_node_name() if target.join_node else "FORK"
+            join_name = (
+                target.join_node.get_node_name()
+                if target.join_node
+                else "FORK"
+            )
+
             await self.observer.on_transition(
                 subject_id, "RUN", f"PARALLEL:{join_name}", duration
             )
@@ -241,11 +264,10 @@ class Engine:
                 )
 
             for branch in target.branches:
-                # Normalize branch to ParallelTask without stripping Wait wrappers
+                # Normalize branch into ParallelTask
                 if isinstance(branch, ParallelTask):
                     task = branch
                 else:
-                    # If it's a Wait or a Node class, wrap it but keep the action intact
                     path = (
                         branch.sub_context_path
                         if isinstance(branch, Wait) and branch.sub_context_path
@@ -253,30 +275,42 @@ class Engine:
                     )
                     task = ParallelTask(action=branch, sub_context_path=path)
 
+                # PROPAGATION: fallback to incoming payload if branch has none
+                branch_payload = (
+                    task.payload if task.payload is not None else payload
+                )
+
                 sub_ctx = self._get_path(context, task.sub_context_path)
+
                 await self._apply_target(
                     f"{subject_id}#{task.sub_context_path}",
                     sub_ctx,
                     task.action,
-                    payload=task.payload,
+                    payload=branch_payload,
                 )
 
             if target.join_node:
                 await self.db.save_state(
-                    subject_id, "WAITING_FOR_JOIN", self._dump_ctx(context), None
+                    subject_id,
+                    "WAITING_FOR_JOIN",
+                    self._dump_ctx(context),
+                    None,
                 )
             else:
                 await self._apply_target(subject_id, context, None)
+
             return
 
         # 7. Schedule (Delayed Execution)
         if isinstance(target, Schedule):
             if not (
-                isinstance(target.action, type) and issubclass(target.action, Node)
+                isinstance(target.action, type)
+                and issubclass(target.action, Node)
             ):
                 raise TypeError("Schedule.action must be a Node class.")
 
             target_node_name = target.action.get_node_name()
+
             await self.observer.on_transition(
                 subject_id, "RUN", f"SCHEDULED:{target_node_name}", duration
             )
@@ -284,10 +318,16 @@ class Engine:
             run_at_dt = datetime.now(timezone.utc) + timedelta(
                 seconds=target.delay_seconds
             )
+
+            # PROPAGATION: fallback to incoming payload if schedule payload is missing
+            final_payload = (
+                target.payload if target.payload is not None else payload
+            )
+
             p_load = (
-                target.payload.model_dump()
-                if hasattr(target.payload, "model_dump")
-                else target.payload
+                final_payload.model_dump()
+                if hasattr(final_payload, "model_dump")
+                else final_payload
             )
 
             scheduled_evt = Event(
@@ -296,15 +336,16 @@ class Engine:
                 payload=p_load,
                 run_at=run_at_dt.isoformat(),
                 idempotency_key=target.idempotency_key,
-                headers=headers,
             )
 
             await self.db.schedule_event(scheduled_evt)
             await self.db.save_state(
-                subject_id, target_node_name, self._dump_ctx(context), None
+                subject_id,
+                target_node_name,
+                self._dump_ctx(context),
+                None,
             )
             return
-
     # --- EXTERNAL CONTROL & SIGNALS ---
 
     async def signal_node(self, subject_id: str, signal_id: str, payload: Any = None):

{commandnet-0.4.2 → commandnet-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "commandnet"
-version = "0.4.2"
+version = "0.5.1"
 description = "A lightweight, Pydantic-powered, distributed event-driven state machine and typed node graph runtime."
 authors = [
     { name = "Christopher Vaz", email = "christophervaz160@gmail.com" }