pyworkflow-engine 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

pyworkflow/__init__.py

@@ -29,7 +29,7 @@ Quick Start:
     >>> run_id = await start(my_workflow, "Alice")
 """
 
-__version__ = "0.1.13"
+__version__ = "0.1.15"
 
 # Configuration
 from pyworkflow.config import (

pyworkflow/celery/singleton.py

@@ -96,7 +96,7 @@ class SingletonWorkflowTask(Task):
     Features:
     - Redis-based lock prevents duplicate execution
     - Support for unique_on with nested dict/list access (e.g., "data.run_id")
-    - Retry-safe: locks NOT released on failure (prevents duplicate during retries)
+    - Retry-safe: lock released in on_retry callback to allow retry to acquire it
     - Lock released on success or when max retries exceeded
     - Time-based lock expiry as safety net
 
@@ -124,7 +124,7 @@ class SingletonWorkflowTask(Task):
 
     # Lock behavior
     release_lock_on_success: bool = True
-    release_lock_on_failure: bool = False  # Keep lock during retries
+    release_lock_on_failure: bool = False  # Only release on max retries exceeded
 
     # Celery task settings
     max_retries: int | None = None
@@ -360,9 +360,11 @@ class SingletonWorkflowTask(Task):
         kwargs: dict[str, Any],
         einfo: Any,
     ) -> None:
-        """Lock is retained during retry."""
+        """Release lock during retry to allow retry task to acquire it."""
+        # Release lock so retry can acquire it via apply_async()
+        self.release_lock(task_args=args, task_kwargs=kwargs)
         logger.warning(
-            f"Task {self.name} retrying (lock retained)",
+            f"Task {self.name} retrying (lock released for retry)",
             task_id=task_id,
             retry_count=self.request.retries,
         )

pyworkflow/celery/tasks.py

@@ -321,7 +321,7 @@ def execute_step_task(
             # Use exponential backoff for unexpected errors
             countdown = _calculate_exponential_backoff(self.request.retries)
             logger.warning(
-                f"Step failed (unexpected): {step_name}, retrying in {countdown:.1f}s...",
+                f"Step failed (unexpected): {step_name}, retrying in {countdown:.1f}s...: {str(e)}",
                 run_id=run_id,
                 step_id=step_id,
                 error=str(e),
@@ -1704,6 +1704,7 @@ async def _start_workflow_on_worker(
 def resume_workflow_task(
     run_id: str,
     storage_config: dict[str, Any] | None = None,
+    triggered_by_hook_id: str | None = None,
 ) -> Any | None:
     """
     Resume a suspended workflow.
@@ -1714,6 +1715,9 @@ def resume_workflow_task(
     Args:
         run_id: Workflow run ID to resume
         storage_config: Storage backend configuration
+        triggered_by_hook_id: Optional hook ID that triggered this resume.
+                              Used to prevent spurious resumes when a workflow
+                              has already moved past the triggering hook.
 
     Returns:
         Workflow result if completed, None if suspended again
@@ -1727,13 +1731,18 @@ def resume_workflow_task(
         f"RESUME_WORKFLOW_TASK ENTRY: {run_id}",
         run_id=run_id,
         celery_task_id=resume_workflow_task.request.id,
+        triggered_by_hook_id=triggered_by_hook_id,
     )
 
     # Get storage backend
     storage = _get_storage_backend(storage_config)
 
     # Resume workflow directly on worker
-    result = run_async(_resume_workflow_on_worker(run_id, storage, storage_config))
+    result = run_async(
+        _resume_workflow_on_worker(
+            run_id, storage, storage_config, triggered_by_hook_id=triggered_by_hook_id
+        )
+    )
 
     if result is not None:
         logger.info(f"Workflow completed on worker: {run_id}")
@@ -1940,15 +1949,81 @@ async def _complete_pending_sleeps(
     return updated_events
 
 
+def _is_hook_still_relevant(hook_id: str, events: list[Any]) -> bool:
+    """
+    Check if a hook is still relevant for resuming the workflow.
+
+    A hook is "still relevant" if there are no newer hooks created after
+    this hook was received. This prevents spurious resumes when:
+    1. resume_hook() is called multiple times for the same hook
+    2. The workflow moved past the first resume and created a new hook
+    3. The duplicate resume task runs but the workflow is now waiting on a different hook
+
+    Args:
+        hook_id: The hook ID that triggered the resume
+        events: List of workflow events
+
+    Returns:
+        True if the hook is still relevant, False if workflow has moved past it
+    """
+    from pyworkflow.engine.events import EventType
+
+    # Sort events by sequence to process in order
+    sorted_events = sorted(events, key=lambda e: e.sequence or 0)
+
+    # Find the sequence number of HOOK_RECEIVED for this hook
+    hook_received_sequence = None
+    for event in sorted_events:
+        if event.type == EventType.HOOK_RECEIVED and event.data.get("hook_id") == hook_id:
+            hook_received_sequence = event.sequence
+            break
+
+    if hook_received_sequence is None:
+        # Hook was never received - shouldn't happen, but allow resume
+        logger.warning(
+            f"Hook {hook_id} was not found in HOOK_RECEIVED events, allowing resume",
+            hook_id=hook_id,
+        )
+        return True
+
+    # Check if there's a HOOK_CREATED event after this hook was received
+    # (indicating the workflow has moved past this hook and created a new one)
+    for event in sorted_events:
+        if event.type == EventType.HOOK_CREATED:
+            event_sequence = event.sequence or 0
+            if event_sequence > hook_received_sequence:
+                # There's a newer hook - this resume is stale
+                newer_hook_id = event.data.get("hook_id")
+                logger.debug(
+                    f"Found newer hook {newer_hook_id} (seq {event_sequence}) "
+                    f"after triggered hook {hook_id} (received at seq {hook_received_sequence})",
+                    hook_id=hook_id,
+                    newer_hook_id=newer_hook_id,
+                )
+                return False
+
+    # No newer hooks created - this resume is still relevant
+    return True
+
+
 async def _resume_workflow_on_worker(
     run_id: str,
     storage: StorageBackend,
     storage_config: dict[str, Any] | None = None,
+    triggered_by_hook_id: str | None = None,
 ) -> Any | None:
     """
     Internal function to resume workflow on Celery worker.
 
     This mirrors the logic from testing.py but runs on workers.
+
+    Args:
+        run_id: Workflow run ID to resume
+        storage: Storage backend
+        storage_config: Storage configuration for task dispatch
+        triggered_by_hook_id: Optional hook ID that triggered this resume.
+                              If provided, we verify the hook is still relevant
+                              before resuming to prevent spurious resumes.
     """
     from pyworkflow.core.exceptions import WorkflowNotFoundError
 
@@ -1983,6 +2058,22 @@ async def _resume_workflow_on_worker(
         )
         return None
 
+    # If this resume was triggered by a specific hook, verify the hook is still relevant.
+    # A hook is "stale" if the workflow has already moved past it (created a newer hook).
+    # This prevents spurious resumes from duplicate resume_hook() calls.
+    if triggered_by_hook_id:
+        events = await storage.get_events(run_id)
+        hook_still_relevant = _is_hook_still_relevant(triggered_by_hook_id, events)
+        if not hook_still_relevant:
+            logger.info(
+                f"Hook {triggered_by_hook_id} is no longer relevant (workflow moved past it), "
+                "skipping spurious resume",
+                run_id=run_id,
+                workflow_name=run.workflow_name,
+                triggered_by_hook_id=triggered_by_hook_id,
+            )
+            return None
+
     # Check for cancellation flag
     cancellation_requested = await storage.check_cancellation_flag(run_id)
 

pyworkflow/context/local.py

@@ -114,6 +114,31 @@ class LocalContext(WorkflowContext):
             self._replay_events(event_log)
             self._is_replaying = False
 
+    def _extract_counter_from_id(self, id_string: str) -> int:
+        """Extract counter value from hook_id or sleep_id.
+
+        Formats:
+        - hook_{name}_{counter}
+        - sleep_{counter}_{duration}s
+
+        Args:
+            id_string: The hook_id or sleep_id string
+
+        Returns:
+            The counter value, or 0 if parsing fails
+        """
+        try:
+            parts = id_string.split("_")
+            if id_string.startswith("hook_"):
+                # hook_{name}_{counter} - counter is last part
+                return int(parts[-1])
+            elif id_string.startswith("sleep_"):
+                # sleep_{counter}_{duration}s - counter is second part
+                return int(parts[1])
+        except (ValueError, IndexError):
+            pass
+        return 0
+
     def _replay_events(self, events: list[Any]) -> None:
         """Replay events to restore state."""
         from pyworkflow.engine.events import EventType
@@ -142,6 +167,12 @@ class LocalContext(WorkflowContext):
                 payload = deserialize(event.data.get("payload"))
                 self._hook_results[hook_id] = payload
 
+            elif event.type == EventType.HOOK_CREATED:
+                # Track pending hooks for re-suspension
+                hook_id = event.data.get("hook_id")
+                if hook_id:
+                    self._pending_hooks[hook_id] = event.data
+
             elif event.type == EventType.STEP_RETRYING:
                 step_id = event.data.get("step_id")
                 self._retry_states[step_id] = {
@@ -893,6 +924,21 @@ class LocalContext(WorkflowContext):
             logger.debug(f"[replay] Hook {hook_id} already received")
             return self._hook_results[hook_id]
 
+        # Check if already pending (created but not yet received - replay mode)
+        # This prevents duplicate hook creation when workflow resumes
+        if hook_id in self._pending_hooks:
+            logger.debug(f"[replay] Hook {hook_id} already pending, re-suspending")
+            pending_data = self._pending_hooks[hook_id]
+            actual_token = pending_data.get("token")
+            # Call on_created callback if provided
+            if on_created is not None:
+                await on_created(actual_token)
+            raise SuspensionSignal(
+                reason=f"hook:{hook_id}",
+                hook_id=hook_id,
+                token=actual_token,
+            )
+
         # Generate composite token: run_id:hook_id
         from pyworkflow.primitives.resume_hook import create_hook_token
 

pyworkflow/primitives/resume_hook.py

@@ -185,6 +185,7 @@ async def resume_hook(
         hook_id=hook_id,
         status=HookStatus.RECEIVED,
         payload=serialized_payload,
+        run_id=run_id,
     )
 
     # Schedule workflow resumption via configured runtime
@@ -195,7 +196,7 @@ async def resume_hook(
     runtime = get_runtime(config.default_runtime)
 
     try:
-        await runtime.schedule_resume(run_id, storage)
+        await runtime.schedule_resume(run_id, storage, triggered_by_hook_id=hook_id)
     except Exception as e:
         logger.warning(
             f"Failed to schedule workflow resumption: {e}",

pyworkflow/runtime/base.py

@@ -97,6 +97,7 @@ class Runtime(ABC):
         self,
         run_id: str,
         storage: "StorageBackend",
+        triggered_by_hook_id: str | None = None,
     ) -> None:
         """
         Schedule a workflow to be resumed immediately.
@@ -109,6 +110,9 @@ class Runtime(ABC):
         Args:
             run_id: The run_id of the workflow to resume
             storage: Storage backend
+            triggered_by_hook_id: Optional hook ID that triggered this resume.
+                                  Used by distributed runtimes to prevent
+                                  spurious resumes from duplicate calls.
         """
         # Default implementation: no-op
         # Subclasses override if they support async scheduling

pyworkflow/runtime/celery.py

@@ -202,25 +202,36 @@ class CeleryRuntime(Runtime):
         self,
         run_id: str,
         storage: "StorageBackend",
+        triggered_by_hook_id: str | None = None,
     ) -> None:
         """
         Schedule immediate workflow resumption via Celery task.
 
         This is called by resume_hook() to trigger workflow resumption
         after a hook event is received.
+
+        Args:
+            run_id: The workflow run ID to resume
+            storage: Storage backend for configuration
+            triggered_by_hook_id: Optional hook ID that triggered this resume.
+                                  Used to prevent spurious resumes from duplicate calls.
         """
         from pyworkflow.celery.tasks import resume_workflow_task
 
         logger.info(
             f"Scheduling workflow resume via Celery: {run_id}",
             run_id=run_id,
+            triggered_by_hook_id=triggered_by_hook_id,
         )
 
         storage_config = self._get_storage_config(storage)
 
         resume_workflow_task.apply_async(
             args=[run_id],
-            kwargs={"storage_config": storage_config},
+            kwargs={
+                "storage_config": storage_config,
+                "triggered_by_hook_id": triggered_by_hook_id,
+            },
         )
 
         logger.info(

pyworkflow/runtime/local.py

@@ -507,16 +507,24 @@ class LocalRuntime(Runtime):
         self,
         run_id: str,
         storage: "StorageBackend",
+        triggered_by_hook_id: str | None = None,
     ) -> None:
         """
         Schedule immediate workflow resumption.
 
         For local runtime, this directly calls resume_workflow since
         execution happens in-process.
+
+        Args:
+            run_id: The workflow run ID to resume
+            storage: Storage backend
+            triggered_by_hook_id: Optional hook ID that triggered this resume.
+                                  Not used in local runtime (no queueing).
         """
         logger.info(
             f"Scheduling immediate workflow resume: {run_id}",
             run_id=run_id,
+            triggered_by_hook_id=triggered_by_hook_id,
         )
 
         try:

pyworkflow/storage/base.py

@@ -291,12 +291,13 @@ class StorageBackend(ABC):
         pass
 
     @abstractmethod
-    async def get_hook(self, hook_id: str) -> Hook | None:
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
         """
         Retrieve a hook by ID.
 
         Args:
             hook_id: Hook identifier
+            run_id: Run ID (required for composite key lookup in SQL backends)
 
         Returns:
             Hook if found, None otherwise
@@ -322,6 +323,7 @@ class StorageBackend(ABC):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """
         Update hook status and optionally payload.
@@ -330,6 +332,7 @@ class StorageBackend(ABC):
             hook_id: Hook identifier
             status: New status
             payload: JSON serialized payload (if received)
+            run_id: Run ID (required for composite key lookup in SQL backends)
         """
         pass
 

pyworkflow/storage/cassandra.py

@@ -1072,29 +1072,31 @@ class CassandraStorageBackend(StorageBackend):
 
         session.execute(batch)
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (run_id allows skipping lookup table)."""
         session = self._ensure_connected()
 
-        # First lookup run_id
-        lookup = session.execute(
-            SimpleStatement(
-                "SELECT run_id FROM hooks_by_id WHERE hook_id = %s",
-                consistency_level=self.read_consistency,
-            ),
-            (hook_id,),
-        ).one()
+        if not run_id:
+            # First lookup run_id from lookup table
+            lookup = session.execute(
+                SimpleStatement(
+                    "SELECT run_id FROM hooks_by_id WHERE hook_id = %s",
+                    consistency_level=self.read_consistency,
+                ),
+                (hook_id,),
+            ).one()
 
-        if not lookup:
-            return None
+            if not lookup:
+                return None
+            run_id = lookup.run_id
 
-        # Then get full hook
+        # Get full hook
         row = session.execute(
             SimpleStatement(
                 "SELECT * FROM hooks WHERE run_id = %s AND hook_id = %s",
                 consistency_level=self.read_consistency,
             ),
-            (lookup.run_id, hook_id),
+            (run_id, hook_id),
         ).one()
 
         if not row:
@@ -1137,21 +1139,24 @@ class CassandraStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         session = self._ensure_connected()
 
-        # First lookup run_id
-        lookup = session.execute(
-            SimpleStatement(
-                "SELECT run_id FROM hooks_by_id WHERE hook_id = %s",
-                consistency_level=self.read_consistency,
-            ),
-            (hook_id,),
-        ).one()
+        if not run_id:
+            # First lookup run_id from lookup table
+            lookup = session.execute(
+                SimpleStatement(
+                    "SELECT run_id FROM hooks_by_id WHERE hook_id = %s",
+                    consistency_level=self.read_consistency,
+                ),
+                (hook_id,),
+            ).one()
 
-        if not lookup:
-            return
+            if not lookup:
+                return
+            run_id = lookup.run_id
 
         received_at = datetime.now(UTC) if status == HookStatus.RECEIVED else None
 
@@ -1164,7 +1169,7 @@ class CassandraStorageBackend(StorageBackend):
                 """,
                 consistency_level=self.write_consistency,
             ),
-            (status.value, payload, received_at, lookup.run_id, hook_id),
+            (status.value, payload, received_at, run_id, hook_id),
         )
 
     async def list_hooks(

pyworkflow/storage/dynamodb.py

@@ -722,9 +722,9 @@ class DynamoDBStorageBackend(StorageBackend):
     async def create_hook(self, hook: Hook) -> None:
         """Create a hook record."""
         async with self._get_client() as client:
-            # Main hook item
+            # Main hook item (composite key: run_id + hook_id)
             item = {
-                "PK": f"HOOK#{hook.hook_id}",
+                "PK": f"HOOK#{hook.run_id}#{hook.hook_id}",
                 "SK": "#METADATA",
                 "entity_type": "hook",
                 "hook_id": hook.hook_id,
@@ -741,12 +741,13 @@ class DynamoDBStorageBackend(StorageBackend):
                 "GSI1SK": f"{hook.status.value}#{hook.created_at.isoformat()}",
             }
 
-            # Token lookup item
+            # Token lookup item (stores run_id and hook_id for lookup)
             token_item = {
                 "PK": f"TOKEN#{hook.token}",
-                "SK": f"HOOK#{hook.hook_id}",
+                "SK": f"HOOK#{hook.run_id}#{hook.hook_id}",
                 "entity_type": "hook_token",
                 "hook_id": hook.hook_id,
+                "run_id": hook.run_id,
             }
 
             # Write both items
@@ -759,16 +760,26 @@ class DynamoDBStorageBackend(StorageBackend):
                 Item=self._dict_to_item(token_item),
             )
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key)."""
         async with self._get_client() as client:
-            response = await client.get_item(
-                TableName=self.table_name,
-                Key={
-                    "PK": {"S": f"HOOK#{hook_id}"},
-                    "SK": {"S": "#METADATA"},
-                },
-            )
+            if run_id:
+                response = await client.get_item(
+                    TableName=self.table_name,
+                    Key={
+                        "PK": {"S": f"HOOK#{run_id}#{hook_id}"},
+                        "SK": {"S": "#METADATA"},
+                    },
+                )
+            else:
+                # Fallback: try old format without run_id
+                response = await client.get_item(
+                    TableName=self.table_name,
+                    Key={
+                        "PK": {"S": f"HOOK#{hook_id}"},
+                        "SK": {"S": "#METADATA"},
+                    },
+                )
 
             item = response.get("Item")
             if not item:
@@ -779,7 +790,7 @@ class DynamoDBStorageBackend(StorageBackend):
     async def get_hook_by_token(self, token: str) -> Hook | None:
         """Retrieve a hook by its token."""
         async with self._get_client() as client:
-            # First get the hook_id from the token lookup item
+            # First get the hook_id and run_id from the token lookup item
             response = await client.query(
                 TableName=self.table_name,
                 KeyConditionExpression="PK = :pk",
@@ -792,13 +803,16 @@ class DynamoDBStorageBackend(StorageBackend):
                 return None
 
             hook_id = self._deserialize_value(items[0]["hook_id"])
-            return await self.get_hook(hook_id)
+            run_id_attr = items[0].get("run_id")
+            run_id = self._deserialize_value(run_id_attr) if run_id_attr else None
+            return await self.get_hook(hook_id, run_id)
 
     async def update_hook_status(
         self,
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         async with self._get_client() as client:
@@ -814,10 +828,12 @@ class DynamoDBStorageBackend(StorageBackend):
                 update_expr += ", received_at = :received_at"
                 expr_values[":received_at"] = {"S": datetime.now(UTC).isoformat()}
 
+            pk = f"HOOK#{run_id}#{hook_id}" if run_id else f"HOOK#{hook_id}"
+
             await client.update_item(
                 TableName=self.table_name,
                 Key={
-                    "PK": {"S": f"HOOK#{hook_id}"},
+                    "PK": {"S": pk},
                     "SK": {"S": "#METADATA"},
                 },
                 UpdateExpression=update_expr,

pyworkflow/storage/file.py

@@ -464,7 +464,8 @@ class FileStorageBackend(StorageBackend):
 
     async def create_hook(self, hook: Hook) -> None:
         """Create a hook record."""
-        hook_file = self.hooks_dir / f"{hook.hook_id}.json"
+        # Use composite filename: run_id__hook_id.json (double underscore separator)
+        hook_file = self.hooks_dir / f"{hook.run_id}__{hook.hook_id}.json"
         lock_file = self.locks_dir / "token_index.lock"
         lock = FileLock(str(lock_file))
 
@@ -473,16 +474,25 @@ class FileStorageBackend(StorageBackend):
         def _write() -> None:
             with lock:
                 hook_file.write_text(json.dumps(data, indent=2))
-                # Update token index
+                # Update token index (stores run_id:hook_id as value)
                 index = self._load_token_index()
-                index[hook.token] = hook.hook_id
+                index[hook.token] = f"{hook.run_id}:{hook.hook_id}"
                 self._save_token_index(index)
 
         await asyncio.to_thread(_write)
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
-        hook_file = self.hooks_dir / f"{hook_id}.json"
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite filename)."""
+        if run_id:
+            hook_file = self.hooks_dir / f"{run_id}__{hook_id}.json"
+        else:
+            # Fallback: try old format for backwards compat
+            hook_file = self.hooks_dir / f"{hook_id}.json"
+            if not hook_file.exists():
+                # Search for any file with this hook_id
+                for f in self.hooks_dir.glob(f"*__{hook_id}.json"):
+                    hook_file = f
+                    break
 
         if not hook_file.exists():
             return None
@@ -496,13 +506,18 @@ class FileStorageBackend(StorageBackend):
     async def get_hook_by_token(self, token: str) -> Hook | None:
         """Retrieve a hook by its token."""
 
-        def _lookup() -> str | None:
+        def _lookup() -> tuple[str, str] | None:
             index = self._load_token_index()
-            return index.get(token)
+            value = index.get(token)
+            if value and ":" in value:
+                parts = value.split(":", 1)
+                return (parts[0], parts[1])
+            return None
 
-        hook_id = await asyncio.to_thread(_lookup)
-        if hook_id:
-            return await self.get_hook(hook_id)
+        result = await asyncio.to_thread(_lookup)
+        if result:
+            run_id, hook_id = result
+            return await self.get_hook(hook_id, run_id)
         return None
 
     async def update_hook_status(
@@ -510,14 +525,25 @@ class FileStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
-        hook_file = self.hooks_dir / f"{hook_id}.json"
+        if run_id:
+            hook_file = self.hooks_dir / f"{run_id}__{hook_id}.json"
+        else:
+            # Fallback: try old format
+            hook_file = self.hooks_dir / f"{hook_id}.json"
+            if not hook_file.exists():
+                # Search for any file with this hook_id
+                for f in self.hooks_dir.glob(f"*__{hook_id}.json"):
+                    hook_file = f
+                    break
 
         if not hook_file.exists():
             raise ValueError(f"Hook {hook_id} not found")
 
-        lock_file = self.locks_dir / f"hook_{hook_id}.lock"
+        safe_hook_id = hook_id.replace("/", "_").replace(":", "_")
+        lock_file = self.locks_dir / f"hook_{safe_hook_id}.lock"
         lock = FileLock(str(lock_file))
 
         def _update() -> None:

pyworkflow/storage/memory.py

@@ -43,10 +43,10 @@ class InMemoryStorageBackend(StorageBackend):
         self._runs: dict[str, WorkflowRun] = {}
         self._events: dict[str, list[Event]] = {}
         self._steps: dict[str, StepExecution] = {}
-        self._hooks: dict[str, Hook] = {}
+        self._hooks: dict[tuple[str, str], Hook] = {}  # (run_id, hook_id) -> Hook
         self._schedules: dict[str, Schedule] = {}
         self._idempotency_index: dict[str, str] = {}  # key -> run_id
-        self._token_index: dict[str, str] = {}  # token -> hook_id
+        self._token_index: dict[str, tuple[str, str]] = {}  # token -> (run_id, hook_id)
         self._cancellation_flags: dict[str, bool] = {}  # run_id -> cancelled
         self._lock = threading.RLock()
         self._event_sequences: dict[str, int] = {}  # run_id -> next sequence
@@ -292,20 +292,28 @@ class InMemoryStorageBackend(StorageBackend):
     async def create_hook(self, hook: Hook) -> None:
         """Create a hook record."""
         with self._lock:
-            self._hooks[hook.hook_id] = hook
-            self._token_index[hook.token] = hook.hook_id
+            key = (hook.run_id, hook.hook_id)
+            self._hooks[key] = hook
+            self._token_index[hook.token] = key
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         with self._lock:
-            return self._hooks.get(hook_id)
+            if run_id:
+                return self._hooks.get((run_id, hook_id))
+            else:
+                # Fallback: find any hook with this ID (may return wrong one if duplicates)
+                for (_r_id, h_id), hook in self._hooks.items():
+                    if h_id == hook_id:
+                        return hook
+                return None
 
     async def get_hook_by_token(self, token: str) -> Hook | None:
         """Retrieve a hook by its token."""
         with self._lock:
-            hook_id = self._token_index.get(token)
-            if hook_id:
-                return self._hooks.get(hook_id)
+            key = self._token_index.get(token)
+            if key:
+                return self._hooks.get(key)
             return None
 
     async def update_hook_status(
@@ -313,10 +321,19 @@ class InMemoryStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         with self._lock:
-            hook = self._hooks.get(hook_id)
+            if run_id:
+                hook = self._hooks.get((run_id, hook_id))
+            else:
+                # Fallback: find any hook with this ID
+                hook = None
+                for (_r_id, h_id), h in self._hooks.items():
+                    if h_id == hook_id:
+                        hook = h
+                        break
             if hook:
                 hook.status = status
                 if payload is not None:

pyworkflow/storage/mysql.py

@@ -175,11 +175,11 @@ class MySQLStorageBackend(StorageBackend):
                     ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
                 """)
 
-            # Hooks table
+            # Hooks table (composite PK: run_id + hook_id since hook_id is only unique per run)
             await cur.execute("""
                     CREATE TABLE IF NOT EXISTS hooks (
-                        hook_id VARCHAR(255) PRIMARY KEY,
                         run_id VARCHAR(255) NOT NULL,
+                        hook_id VARCHAR(255) NOT NULL,
                         token VARCHAR(255) UNIQUE NOT NULL,
                         created_at DATETIME(6) NOT NULL,
                         received_at DATETIME(6),
@@ -187,6 +187,7 @@ class MySQLStorageBackend(StorageBackend):
                         status VARCHAR(50) NOT NULL,
                         payload LONGTEXT,
                         metadata LONGTEXT DEFAULT '{}',
+                        PRIMARY KEY (run_id, hook_id),
                         UNIQUE INDEX idx_hooks_token (token),
                         INDEX idx_hooks_run_id (run_id),
                         INDEX idx_hooks_status (status),
@@ -660,12 +661,19 @@ class MySQLStorageBackend(StorageBackend):
                 ),
             )
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         pool = self._ensure_connected()
 
         async with pool.acquire() as conn, conn.cursor(aiomysql.DictCursor) as cur:
-            await cur.execute("SELECT * FROM hooks WHERE hook_id = %s", (hook_id,))
+            if run_id:
+                await cur.execute(
+                    "SELECT * FROM hooks WHERE run_id = %s AND hook_id = %s",
+                    (run_id, hook_id),
+                )
+            else:
+                # Fallback: find any hook with this ID (may return wrong one if duplicates)
+                await cur.execute("SELECT * FROM hooks WHERE hook_id = %s", (hook_id,))
             row = await cur.fetchone()
 
         if not row:
@@ -691,6 +699,7 @@ class MySQLStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         pool = self._ensure_connected()
@@ -706,13 +715,20 @@ class MySQLStorageBackend(StorageBackend):
             updates.append("received_at = %s")
             params.append(datetime.now(UTC))
 
-        params.append(hook_id)
-
         async with pool.acquire() as conn, conn.cursor() as cur:
-            await cur.execute(
-                f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = %s",
-                tuple(params),
-            )
+            if run_id:
+                params.append(run_id)
+                params.append(hook_id)
+                await cur.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE run_id = %s AND hook_id = %s",
+                    tuple(params),
+                )
+            else:
+                params.append(hook_id)
+                await cur.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = %s",
+                    tuple(params),
+                )
 
     async def list_hooks(
         self,

pyworkflow/storage/postgres.py

@@ -216,18 +216,19 @@ class PostgresStorageBackend(StorageBackend):
             # Indexes for steps
             await conn.execute("CREATE INDEX IF NOT EXISTS idx_steps_run_id ON steps(run_id)")
 
-            # Hooks table
+            # Hooks table (composite PK: run_id + hook_id since hook_id is only unique per run)
             await conn.execute("""
                 CREATE TABLE IF NOT EXISTS hooks (
-                    hook_id TEXT PRIMARY KEY,
                     run_id TEXT NOT NULL REFERENCES workflow_runs(run_id) ON DELETE CASCADE,
+                    hook_id TEXT NOT NULL,
                     token TEXT UNIQUE NOT NULL,
                     created_at TIMESTAMPTZ NOT NULL,
                     received_at TIMESTAMPTZ,
                     expires_at TIMESTAMPTZ,
                     status TEXT NOT NULL,
                     payload TEXT,
-                    metadata TEXT DEFAULT '{}'
+                    metadata TEXT DEFAULT '{}',
+                    PRIMARY KEY (run_id, hook_id)
                 )
             """)
 
@@ -751,12 +752,20 @@ class PostgresStorageBackend(StorageBackend):
                 json.dumps(hook.metadata),
             )
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         pool = await self._get_pool()
 
         async with pool.acquire() as conn:
-            row = await conn.fetchrow("SELECT * FROM hooks WHERE hook_id = $1", hook_id)
+            if run_id:
+                row = await conn.fetchrow(
+                    "SELECT * FROM hooks WHERE run_id = $1 AND hook_id = $2",
+                    run_id,
+                    hook_id,
+                )
+            else:
+                # Fallback: find any hook with this ID (may return wrong one if duplicates)
+                row = await conn.fetchrow("SELECT * FROM hooks WHERE hook_id = $1", hook_id)
 
         if not row:
             return None
@@ -780,6 +789,7 @@ class PostgresStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         pool = await self._get_pool()
@@ -798,13 +808,20 @@ class PostgresStorageBackend(StorageBackend):
             params.append(datetime.now(UTC))
             param_idx += 1
 
-        params.append(hook_id)
-
         async with pool.acquire() as conn:
-            await conn.execute(
-                f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ${param_idx}",
-                *params,
-            )
+            if run_id:
+                params.append(run_id)
+                params.append(hook_id)
+                await conn.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE run_id = ${param_idx} AND hook_id = ${param_idx + 1}",
+                    *params,
+                )
+            else:
+                params.append(hook_id)
+                await conn.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ${param_idx}",
+                    *params,
+                )
 
     async def list_hooks(
         self,

pyworkflow/storage/sqlite.py

@@ -164,11 +164,11 @@ class SQLiteStorageBackend(StorageBackend):
         # Indexes for steps
         await db.execute("CREATE INDEX IF NOT EXISTS idx_steps_run_id ON steps(run_id)")
 
-        # Hooks table
+        # Hooks table (composite PK: run_id + hook_id since hook_id is only unique per run)
         await db.execute("""
             CREATE TABLE IF NOT EXISTS hooks (
-                hook_id TEXT PRIMARY KEY,
                 run_id TEXT NOT NULL,
+                hook_id TEXT NOT NULL,
                 token TEXT UNIQUE NOT NULL,
                 created_at TIMESTAMP NOT NULL,
                 received_at TIMESTAMP,
@@ -176,6 +176,7 @@ class SQLiteStorageBackend(StorageBackend):
                 status TEXT NOT NULL,
                 payload TEXT,
                 metadata TEXT DEFAULT '{}',
+                PRIMARY KEY (run_id, hook_id),
                 FOREIGN KEY (run_id) REFERENCES workflow_runs(run_id) ON DELETE CASCADE
             )
         """)
@@ -645,12 +646,20 @@ class SQLiteStorageBackend(StorageBackend):
         )
         await db.commit()
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         db = self._ensure_connected()
 
-        async with db.execute("SELECT * FROM hooks WHERE hook_id = ?", (hook_id,)) as cursor:
-            row = await cursor.fetchone()
+        if run_id:
+            async with db.execute(
+                "SELECT * FROM hooks WHERE run_id = ? AND hook_id = ?",
+                (run_id, hook_id),
+            ) as cursor:
+                row = await cursor.fetchone()
+        else:
+            # Fallback: find any hook with this ID (may return wrong one if duplicates)
+            async with db.execute("SELECT * FROM hooks WHERE hook_id = ?", (hook_id,)) as cursor:
+                row = await cursor.fetchone()
 
         if not row:
             return None
@@ -674,6 +683,7 @@ class SQLiteStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         db = self._ensure_connected()
@@ -689,12 +699,19 @@ class SQLiteStorageBackend(StorageBackend):
             updates.append("received_at = ?")
             params.append(datetime.now(UTC).isoformat())
 
-        params.append(hook_id)
-
-        await db.execute(
-            f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ?",
-            tuple(params),
-        )
+        if run_id:
+            params.append(run_id)
+            params.append(hook_id)
+            await db.execute(
+                f"UPDATE hooks SET {', '.join(updates)} WHERE run_id = ? AND hook_id = ?",
+                tuple(params),
+            )
+        else:
+            params.append(hook_id)
+            await db.execute(
+                f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ?",
+                tuple(params),
+            )
         await db.commit()
 
     async def list_hooks(

{pyworkflow_engine-0.1.13.dist-info → pyworkflow_engine-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyworkflow-engine
-Version: 0.1.13
+Version: 0.1.15
 Summary: A Python implementation of durable, event-sourced workflows inspired by Vercel Workflow
 Author: PyWorkflow Contributors
 License: MIT

{pyworkflow_engine-0.1.13.dist-info → pyworkflow_engine-0.1.15.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyworkflow/__init__.py,sha256=C7t5zLS32QNzI2BXNdGpWXwzgNyUVchs6L7dcx0p84c,6281
+pyworkflow/__init__.py,sha256=y7ZDE1MHyoDPMBh_mnmHhmtYxFeZV0aSWeKpUn6JXuA,6281
 pyworkflow/config.py,sha256=pKwPrpCwBJiDpB-MIjM0U7GW1TFmQFO341pihL5-vTM,14455
 pyworkflow/discovery.py,sha256=snW3l4nvY3Nc067TGlwtn_qdzTU9ybN7YPr8FbvY8iM,8066
 pyworkflow/aws/__init__.py,sha256=Ak_xHcR9LTRX-CwcS0XecYmzrXZw4EM3V9aKBBDEmIk,1741
@@ -9,8 +9,8 @@ pyworkflow/celery/__init__.py,sha256=FywVyqnT8AYz9cXkr-wel7_-N7dHFsPNASEPMFESf4Q
 pyworkflow/celery/app.py,sha256=UwZauZjVzOxMPX3WmPilRi8Emg5_VbMjHjNn7uz7R14,9670
 pyworkflow/celery/loop.py,sha256=mu8cIfMJYgHAoGCN_DdDoNoXK3QHzHpLmrPCyFDQYIY,3016
 pyworkflow/celery/scheduler.py,sha256=Ms4rqRpdpMiLM8l4y3DK-Divunj9afYuUaGGoNQe7P4,11288
-pyworkflow/celery/singleton.py,sha256=BykAovBVP0XUo2ZbTQzD4fANa6C_lHSqqaWnhfNfQGw,12978
-pyworkflow/celery/tasks.py,sha256=uHpOoHvZd72CYxCG4yhjgyT7j12fOoyf2380pJgMACs,82083
+pyworkflow/celery/singleton.py,sha256=J4a5LY5GsSFbO2evkql4Pw7h38tA2rQbR3J2cXkJRZg,13155
+pyworkflow/celery/tasks.py,sha256=BNHZwWTSRc3q8EgAy4tEmXAm6O0vtVLgrG7MrO0ZZXA,86049
 pyworkflow/cli/__init__.py,sha256=tcbe-fcZmyeEKUy_aEo8bsEF40HsNKOwvyMBZIJZPwc,3844
 pyworkflow/cli/__main__.py,sha256=LxLLS4FEEPXa5rWpLTtKuivn6Xp9pGia-QKGoxt9SS0,148
 pyworkflow/cli/commands/__init__.py,sha256=IXvnTgukALckkO8fTlZhVRq80ojSqpnIIgboAg_-yZU,39
@@ -36,7 +36,7 @@ pyworkflow/cli/utils/storage.py,sha256=a5Iu2Xe1_mPgBVYc8B6I63MFfW12ko7wURqcpq3RB
 pyworkflow/context/__init__.py,sha256=dI5zW1lAFGw68jI2UpKUqyADozDboGNl-RmhEvSTuCI,2150
 pyworkflow/context/aws.py,sha256=MYxrFsRzCgaZ0YQAyE26UOT_ryxuag5DwiDSodclQIg,7571
 pyworkflow/context/base.py,sha256=Hlfm5MNHh_BVbRCgEcILmHiqsn81iYFqt0GSLkFGo00,13772
-pyworkflow/context/local.py,sha256=H9UTuIWjelP4Nsc16guDf_fSMxVsIyfzbymJclvADhw,37118
+pyworkflow/context/local.py,sha256=eKBF-e_WSkVIqbynVysQy6rH02rXmPts29KtjY41IQI,38853
 pyworkflow/context/mock.py,sha256=TJzQ3P3_ZHm1lCJZJACIFFvz2ydFxz2cT9eEGOQS5I0,12061
 pyworkflow/context/step_context.py,sha256=6P2jn1v7MTlYaWCTt6DBq7Nkmxm7nvna4oGpTZJeMbg,8862
 pyworkflow/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,37 +58,37 @@ pyworkflow/primitives/child_workflow.py,sha256=_T7PCqiH0tjIm_lpJ6NmfUPWCFx-MjH6t
 pyworkflow/primitives/continue_as_new.py,sha256=NKcimHsgr5ExkvRvfO28hxgPw_I7Q74Vz9WL8r0PhPc,3329
 pyworkflow/primitives/define_hook.py,sha256=gNzk7DuObfWG1T9AdHnDnGLHNKjnApiVRlCKPObugfY,4443
 pyworkflow/primitives/hooks.py,sha256=ws9U81ymsY8M4FFTvJ2X4EMGmIrilb3vCKZ0V_EGZdE,3085
-pyworkflow/primitives/resume_hook.py,sha256=q6gb0qsAhOkFRKMs-PkbLSFLnLerx0VGMkPp9CbkXZQ,6192
+pyworkflow/primitives/resume_hook.py,sha256=vwa0znU1DuasStzQVTES-jp9XUzbVq4vimmbpiZH6yg,6245
 pyworkflow/primitives/schedule.py,sha256=2hVM2Swl9dRx3RHd5nblJLaU8HaSy-NHYue2Cf9TOcU,14961
 pyworkflow/primitives/shield.py,sha256=MUYakU0euZoYNb6MbFyRfJN8GEXsRFkIbZEo84vRN9c,2924
 pyworkflow/primitives/sleep.py,sha256=iH1e5CoWY-jZbYNAU3GRW1xR_8EtCuPIcIohzU4jWJo,3097
 pyworkflow/runtime/__init__.py,sha256=DkwTgFCMRGyyW8NGcW7Nyy9beOg5kO1TXhqhysj1-aY,649
-pyworkflow/runtime/base.py,sha256=-X2pct03XuA3o1P6yD5ywTDgegN6_a450gG8MBVeKRE,5190
-pyworkflow/runtime/celery.py,sha256=FMxiLiRf1pLWD7itEyd6klrH8PjSUOLTxWd7E8TyOG4,9476
+pyworkflow/runtime/base.py,sha256=ATlPeheYzUMlk_v-9abLyUQf4y4iYB53VpaoQ73pYsc,5465
+pyworkflow/runtime/celery.py,sha256=JadRjmpL1rsp-zNAHq3vL8XdAhKucu1vEsxGvshaLjk,9961
 pyworkflow/runtime/factory.py,sha256=TRbqWPfyZ0tPFKb0faI9SkBRXxE5AEVTwGW4pS2diM8,2684
-pyworkflow/runtime/local.py,sha256=8mhUyMJDseXFsO0XvwJN6QkXd_4tjPEHG1_N_BmJgsE,25868
+pyworkflow/runtime/local.py,sha256=UPOdJsejrWzdz5p1XpTfMgWC0EK85qT7HHBUjmJ4xOQ,26228
 pyworkflow/scheduler/__init__.py,sha256=lQQo0Cia_ULIg-KPIrqILV30rUIzybxj1k_ZZTQNZyg,222
 pyworkflow/scheduler/local.py,sha256=CnK4UC6ofD3_AZJUlO9iUAdgAnbMmJvPaL_VucNKs5Q,8154
 pyworkflow/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyworkflow/serialization/decoder.py,sha256=F7Ofuw1Yzo82iSFFXiK2yoW_v2YRbLMpX3CQbKjm0Ls,3860
 pyworkflow/serialization/encoder.py,sha256=ZBwAxe5Bb4MCfFJePHw7ArJlIbBieSwUgsysGCI2iPU,4108
 pyworkflow/storage/__init__.py,sha256=LhVjLNZdo4Mi5dEC75hjSPnbQr9jBoIsTOrC8vzTGOM,1924
-pyworkflow/storage/base.py,sha256=DxgOB9kr3i1uaitY_E9PzhnNWxaq1U5EvbbSjKyoH8M,16104
-pyworkflow/storage/cassandra.py,sha256=Nig0SUlTyxuNgPjOXnVBlzDq3PAGci4jIT1JI0i-GOk,61428
+pyworkflow/storage/base.py,sha256=ZS0jTdBRmT4nhADIPpr_MmOvqQvhse3LSb6CDt5rr-4,16324
+pyworkflow/storage/cassandra.py,sha256=DTJJr4yqAV-941YjQQdoO1-5SsFoqke82sXpBrXPyKg,61741
 pyworkflow/storage/config.py,sha256=45UMPxRoqgK4ZwE7HIK9ctxE_eoK3eAE_1tRhn3Psd4,12410
-pyworkflow/storage/dynamodb.py,sha256=tGNQQqESxhZzOP5NJULCZKcQf9UuSQNL17TJo6R1jlw,53301
-pyworkflow/storage/file.py,sha256=lKilavXn_CRiIVL5XeV7tY9lm2vJADH-h9Teg0gA84A,28842
-pyworkflow/storage/memory.py,sha256=r2z6LiRw8J2AbO9Qw2wtYjzGfX-VJlRX_RVI2U8c-hs,19753
-pyworkflow/storage/mysql.py,sha256=f1aGyAL8fGsLnmHkpEwP4MFSwvYTpQxOBECHKCnetGI,42904
-pyworkflow/storage/postgres.py,sha256=KrDVF715YSEFouNVQOG6g-ekNvkTtrNxqWSvJMYueeM,44450
+pyworkflow/storage/dynamodb.py,sha256=8ClKZeP3TURDVJN2SJMAoLWWSXAgqysQXnqUXoRhaos,54159
+pyworkflow/storage/file.py,sha256=g2eO-MOaQKliM97_gTVGPS27GmH5mahi5GBZ99RP8Rs,30133
+pyworkflow/storage/memory.py,sha256=J5ZA2DsXE5tEQDn5dmtJ3mNEWy9okR6sTYZ-xp3slWY,20554
+pyworkflow/storage/mysql.py,sha256=lA2TRBvYlWEq5mQcnfyRivFO1n0kviq_yH3mEzGp8rs,43764
+pyworkflow/storage/postgres.py,sha256=GUW2OjV6CHWi9fUkUPswmGwvaY7c76QxIQ9kRL8BM6o,45351
 pyworkflow/storage/schemas.py,sha256=o1ntTYNgQQ5YVuXtPCShtENEsndVjdrXclWrkCgkitg,18002
-pyworkflow/storage/sqlite.py,sha256=oBzJnnOp2uk0-U7hMTQk9QgJq3RBwXPQfrmYpivjdgE,39529
+pyworkflow/storage/sqlite.py,sha256=qDhFjyFAenwYq6MF_66FFhDaBG7CEr7ni9Uy72X7MvQ,40377
 pyworkflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyworkflow/utils/duration.py,sha256=C-itmiSQQlplw7j6XB679hLF9xYGnyCwm7twO88OF8U,3978
 pyworkflow/utils/schedule.py,sha256=dO_MkGFyfwZpb0LDlW6BGyZzlPuQIA6dc6j9nk9lc4Y,10691
-pyworkflow_engine-0.1.13.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
-pyworkflow_engine-0.1.13.dist-info/METADATA,sha256=zqczKyklwOmbUKz9hfYrmhxP_ZteNp49g7RoB8zPaSM,19628
-pyworkflow_engine-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyworkflow_engine-0.1.13.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
-pyworkflow_engine-0.1.13.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
-pyworkflow_engine-0.1.13.dist-info/RECORD,,
+pyworkflow_engine-0.1.15.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
+pyworkflow_engine-0.1.15.dist-info/METADATA,sha256=U7Dxscf56DPD5TOPCvuyeR75XF5CnftWN78i2yboZBU,19628
+pyworkflow_engine-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyworkflow_engine-0.1.15.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
+pyworkflow_engine-0.1.15.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
+pyworkflow_engine-0.1.15.dist-info/RECORD,,