commandnet 0.5.0__tar.gz → 0.6.0__tar.gz

{commandnet-0.5.0 → commandnet-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commandnet
-Version: 0.5.0
+Version: 0.6.0
 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.5.0 → commandnet-0.6.0}/commandnet/__init__.py

@@ -1,5 +1,5 @@
 from .core.models import Event
-from .core.node import Node, Parallel, ParallelTask, Schedule, Wait, Call, Interrupt
+from .core.node import Node, Parallel, ParallelTask, Schedule, Wait, Call, Interrupt, Transition
 from .core.graph import GraphAnalyzer
 from .interfaces.persistence import Persistence
 from .interfaces.event_bus import EventBus
@@ -9,6 +9,6 @@ from .engine.runtime import Engine
 __all__ = [
     "Event", "Node", "Parallel", "ParallelTask", "GraphAnalyzer", 
     "Persistence", "EventBus", "Observer", "Engine", "Schedule",
-    "Call", "Interrupt",
+    "Call", "Interrupt", "Transition",
 ]
 

{commandnet-0.5.0 → commandnet-0.6.0}/commandnet/core/node.py

@@ -5,7 +5,7 @@ C = TypeVar('C', bound=BaseModel) # Context
 P = TypeVar('P', bound=BaseModel) # Payload
 
 # The Recursive Type Definition
-Target = Union[Type['Node'], 'Parallel', 'Schedule', 'Wait', 'Call', 'Interrupt', None]
+Target = Union[Type['Node'], 'Parallel', 'Schedule', 'Wait', 'Call', 'Interrupt', 'Transition', None]
 
 class ParallelTask(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -31,6 +31,11 @@ class Wait(BaseModel):
     resume_action: Target
     sub_context_path: Optional[str] = None 
 
+class Transition(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    node_cls: Type['Node']
+    payload: Optional[Any] = None
+
 class Call(BaseModel):
     """The 'Await' type: Deduplicates execution based on an idempotency key."""
     model_config = ConfigDict(arbitrary_types_allowed=True)

{commandnet-0.5.0 → commandnet-0.6.0}/commandnet/engine/runtime.py

@@ -8,6 +8,7 @@ from ..core.node import (
     Node,
     Parallel,
     Schedule,
+    Transition,
     Wait,
     Target,
     ParallelTask,
@@ -70,8 +71,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 +95,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,
@@ -335,6 +347,20 @@ class Engine:
                 None,
             )
             return
+        if isinstance(target, Transition):
+            node_name = target.node_cls.get_node_name()
+            await self.observer.on_transition(subject_id, "RUN", node_name, duration)
+            
+            # Use the transition's payload, or fallback to the current one
+            final_payload = target.payload if target.payload is not None else payload
+            p_load = final_payload.model_dump() if hasattr(final_payload, "model_dump") else final_payload
+
+            evt = Event(subject_id=subject_id, node_name=node_name, payload=p_load)
+            ctx_dict = self._dump_ctx(context)
+            
+            await self.db.save_state(subject_id, node_name, ctx_dict, evt)
+            await self.bus.publish(evt)
+            return
     # --- EXTERNAL CONTROL & SIGNALS ---
 
     async def signal_node(self, subject_id: str, signal_id: str, payload: Any = None):

{commandnet-0.5.0 → commandnet-0.6.0}/pyproject.toml

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