pyworkflow-engine 0.1.20__py3-none-any.whl → 0.1.22__py3-none-any.whl

pyworkflow/__init__.py

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

pyworkflow/celery/tasks.py

@@ -11,6 +11,7 @@ These tasks enable:
 
 import asyncio
 import random
+import traceback
 import uuid
 from collections.abc import Callable
 from datetime import UTC, datetime
@@ -379,9 +380,9 @@ async def _record_step_completion_and_resume(
 
     Called by execute_step_task after successful step execution.
 
-    Only schedules resume if WORKFLOW_SUSPENDED event exists, indicating
-    the workflow has fully suspended. This prevents race conditions where
-    a step completes before the workflow has suspended.
+    IMPORTANT: This function waits for WORKFLOW_SUSPENDED event before recording
+    STEP_COMPLETED to prevent race conditions where both events get the same
+    sequence number. The workflow must fully suspend before we record completion.
 
     Idempotency: If STEP_COMPLETED already exists for this step_id, skip
     recording and resume scheduling (another task already handled it).
@@ -411,43 +412,67 @@ async def _record_step_completion_and_resume(
         )
         return
 
-    # Record STEP_COMPLETED event
-    completion_event = create_step_completed_event(
-        run_id=run_id,
-        step_id=step_id,
-        result=serialize(result),
-        step_name=step_name,
-    )
-    await storage.record_event(completion_event)
+    # Wait for WORKFLOW_SUSPENDED event before recording STEP_COMPLETED
+    # This prevents race conditions where both events get the same sequence number
+    max_wait_attempts = 50  # 50 * 10ms = 500ms max wait
+    wait_interval = 0.01  # 10ms between checks
 
-    # Refresh events to include the one we just recorded
-    events = await storage.get_events(run_id)
+    for attempt in range(max_wait_attempts):
+        has_suspended = any(
+            evt.type == EventType.WORKFLOW_SUSPENDED
+            and evt.data.get("step_id") == step_id
+            for evt in events
+        )
+        if has_suspended:
+            break
 
-    # Check if workflow has suspended (WORKFLOW_SUSPENDED event exists)
-    # Only schedule resume if workflow has properly suspended
-    has_suspended = any(evt.type == EventType.WORKFLOW_SUSPENDED for evt in events)
+        # Wait and refresh events
+        await asyncio.sleep(wait_interval)
+        events = await storage.get_events(run_id)
 
-    if has_suspended:
-        # Workflow has suspended, safe to schedule resume
-        schedule_workflow_resumption(
-            run_id, datetime.now(UTC), storage_config, triggered_by="step_completed"
-        )
-        logger.info(
-            "Step completed and workflow resumption scheduled",
-            run_id=run_id,
-            step_id=step_id,
-            step_name=step_name,
+        # Also check if step was already completed by another task during wait
+        already_completed = any(
+            evt.type == EventType.STEP_COMPLETED and evt.data.get("step_id") == step_id
+            for evt in events
         )
+        if already_completed:
+            logger.info(
+                "Step already completed by another task during wait, skipping",
+                run_id=run_id,
+                step_id=step_id,
+                step_name=step_name,
+            )
+            return
     else:
-        # Workflow hasn't suspended yet - don't schedule resume
-        # The suspension handler will check for step completion and schedule resume
-        logger.info(
-            "Step completed but workflow not yet suspended, skipping resume scheduling",
+        # Timeout waiting for suspension - log warning but proceed anyway
+        # This handles edge cases where the workflow completes without suspending
+        logger.warning(
+            "Timeout waiting for WORKFLOW_SUSPENDED event, proceeding with completion",
             run_id=run_id,
             step_id=step_id,
             step_name=step_name,
         )
 
+    # Record STEP_COMPLETED event
+    completion_event = create_step_completed_event(
+        run_id=run_id,
+        step_id=step_id,
+        result=serialize(result),
+        step_name=step_name,
+    )
+    await storage.record_event(completion_event)
+
+    # Schedule workflow resumption
+    schedule_workflow_resumption(
+        run_id, datetime.now(UTC), storage_config, triggered_by="step_completed"
+    )
+    logger.info(
+        "Step completed and workflow resumption scheduled",
+        run_id=run_id,
+        step_id=step_id,
+        step_name=step_name,
+    )
+
 
 async def _record_step_failure_and_resume(
     storage_config: dict[str, Any] | None,
@@ -464,9 +489,9 @@ async def _record_step_failure_and_resume(
     Called by execute_step_task after step failure (when retries are exhausted).
     The workflow will fail when it replays and sees the failure event.
 
-    Only schedules resume if WORKFLOW_SUSPENDED event exists, indicating
-    the workflow has fully suspended. This prevents race conditions where
-    a step fails before the workflow has suspended.
+    IMPORTANT: This function waits for WORKFLOW_SUSPENDED event before recording
+    STEP_FAILED to prevent race conditions where both events get the same
+    sequence number. The workflow must fully suspend before we record failure.
 
     Idempotency: If STEP_COMPLETED or terminal STEP_FAILED already exists
     for this step_id, skip recording and resume scheduling.
@@ -500,6 +525,51 @@ async def _record_step_failure_and_resume(
         )
         return
 
+    # Wait for WORKFLOW_SUSPENDED event before recording STEP_FAILED
+    # This prevents race conditions where both events get the same sequence number
+    max_wait_attempts = 50  # 50 * 10ms = 500ms max wait
+    wait_interval = 0.01  # 10ms between checks
+
+    for attempt in range(max_wait_attempts):
+        has_suspended = any(
+            evt.type == EventType.WORKFLOW_SUSPENDED
+            and evt.data.get("step_id") == step_id
+            for evt in events
+        )
+        if has_suspended:
+            break
+
+        # Wait and refresh events
+        await asyncio.sleep(wait_interval)
+        events = await storage.get_events(run_id)
+
+        # Also check if step was already handled by another task during wait
+        already_handled = any(
+            (evt.type == EventType.STEP_COMPLETED and evt.data.get("step_id") == step_id)
+            or (
+                evt.type == EventType.STEP_FAILED
+                and evt.data.get("step_id") == step_id
+                and not evt.data.get("is_retryable", True)
+            )
+            for evt in events
+        )
+        if already_handled:
+            logger.info(
+                "Step already completed/failed by another task during wait, skipping",
+                run_id=run_id,
+                step_id=step_id,
+                step_name=step_name,
+            )
+            return
+    else:
+        # Timeout waiting for suspension - log warning but proceed anyway
+        logger.warning(
+            "Timeout waiting for WORKFLOW_SUSPENDED event, proceeding with failure",
+            run_id=run_id,
+            step_id=step_id,
+            step_name=step_name,
+        )
+
     # Record STEP_FAILED event
     failure_event = create_step_failed_event(
         run_id=run_id,
@@ -511,35 +581,17 @@ async def _record_step_failure_and_resume(
     )
     await storage.record_event(failure_event)
 
-    # Refresh events to include the one we just recorded
-    events = await storage.get_events(run_id)
-
-    # Check if workflow has suspended (WORKFLOW_SUSPENDED event exists)
-    # Only schedule resume if workflow has properly suspended
-    has_suspended = any(evt.type == EventType.WORKFLOW_SUSPENDED for evt in events)
-
-    if has_suspended:
-        # Workflow has suspended, safe to schedule resume
-        schedule_workflow_resumption(
-            run_id, datetime.now(UTC), storage_config, triggered_by="step_failed"
-        )
-        logger.info(
-            "Step failed and workflow resumption scheduled",
-            run_id=run_id,
-            step_id=step_id,
-            step_name=step_name,
-            error=error,
-        )
-    else:
-        # Workflow hasn't suspended yet - don't schedule resume
-        # The suspension handler will check for step failure and schedule resume
-        logger.info(
-            "Step failed but workflow not yet suspended, skipping resume scheduling",
-            run_id=run_id,
-            step_id=step_id,
-            step_name=step_name,
-            error=error,
-        )
+    # Schedule workflow resumption
+    schedule_workflow_resumption(
+        run_id, datetime.now(UTC), storage_config, triggered_by="step_failed"
+    )
+    logger.info(
+        "Step failed and workflow resumption scheduled",
+        run_id=run_id,
+        step_id=step_id,
+        step_name=step_name,
+        error=error,
+    )
 
 
 async def _get_workflow_run_safe(
@@ -1154,8 +1206,14 @@ async def _recover_workflow_on_worker(
         recovery_attempt=run.recovery_attempts,
     )
 
-    # Update status to RUNNING (from RUNNING or INTERRUPTED)
-    await storage.update_run_status(run_id=run_id, status=RunStatus.RUNNING)
+    # Atomically claim the run for recovery.
+    # The run may be in INTERRUPTED or RUNNING state after a worker crash.
+    # Try INTERRUPTED -> RUNNING first (most common recovery path).
+    # If the run is already RUNNING, just set it to RUNNING (idempotent).
+    claimed = await storage.try_claim_run(run_id, RunStatus.INTERRUPTED, RunStatus.RUNNING)
+    if not claimed:
+        # May already be RUNNING from a previous partial recovery - update status directly
+        await storage.update_run_status(run_id=run_id, status=RunStatus.RUNNING)
 
     # Load event log for replay
     events = await storage.get_events(run_id)
@@ -2048,14 +2106,14 @@ async def _resume_workflow_on_worker(
         )
         return None
 
-    # Prevent duplicate resume execution
+    # Atomically claim the run: SUSPENDED -> RUNNING
     # Multiple resume tasks can be scheduled for the same workflow (e.g., race
-    # condition between step completion and suspension handler). Only proceed
-    # if the workflow is actually SUSPENDED. If status is RUNNING, another
-    # resume task got there first.
-    if run.status != RunStatus.SUSPENDED:
+    # condition between step completion and suspension handler). Only one
+    # succeeds; duplicates see the claim fail and return.
+    claimed = await storage.try_claim_run(run_id, RunStatus.SUSPENDED, RunStatus.RUNNING)
+    if not claimed:
         logger.info(
-            f"Workflow status is {run.status.value}, not SUSPENDED - skipping duplicate resume",
+            "Workflow status is not SUSPENDED (already claimed) - skipping duplicate resume",
             run_id=run_id,
             workflow_name=run.workflow_name,
         )
@@ -2075,6 +2133,8 @@ async def _resume_workflow_on_worker(
                 workflow_name=run.workflow_name,
                 triggered_by_hook_id=triggered_by_hook_id,
             )
+            # Revert status back to SUSPENDED since we won't actually resume
+            await storage.update_run_status(run_id=run_id, status=RunStatus.SUSPENDED)
             return None
 
     # Check for cancellation flag
@@ -2084,7 +2144,7 @@ async def _resume_workflow_on_worker(
         f"Resuming workflow execution on worker: {run.workflow_name}",
         run_id=run_id,
         workflow_name=run.workflow_name,
-        current_status=run.status.value,
+        current_status="running",
         cancellation_requested=cancellation_requested,
     )
 
@@ -2103,9 +2163,6 @@ async def _resume_workflow_on_worker(
     args = deserialize_args(run.input_args)
     kwargs = deserialize_kwargs(run.input_kwargs)
 
-    # Update status to running
-    await storage.update_run_status(run_id=run_id, status=RunStatus.RUNNING)
-
     # Execute workflow with event replay
     try:
         result = await execute_workflow_with_context(

pyworkflow/core/step.py

@@ -595,6 +595,7 @@ async def _dispatch_step_to_celery(
     """
     from pyworkflow.celery.tasks import execute_step_task
     from pyworkflow.core.exceptions import SuspensionSignal
+    from pyworkflow.engine.events import EventType
 
     logger.info(
         f"Dispatching step to Celery worker: {step_name}",
@@ -602,6 +603,25 @@ async def _dispatch_step_to_celery(
         step_id=step_id,
     )
 
+    # Defense-in-depth: check if STEP_STARTED was already recorded for this step.
+    # This guards against duplicate dispatch when two resume tasks race and both
+    # replay past the same step. If already started, re-suspend to wait.
+    events = await ctx.storage.get_events(ctx.run_id)
+    already_started = any(
+        evt.type == EventType.STEP_STARTED and evt.data.get("step_id") == step_id for evt in events
+    )
+    if already_started:
+        logger.info(
+            f"Step {step_name} already has STEP_STARTED event, re-suspending",
+            run_id=ctx.run_id,
+            step_id=step_id,
+        )
+        raise SuspensionSignal(
+            reason=f"step_dispatch:{step_id}",
+            step_id=step_id,
+            step_name=step_name,
+        )
+
     # Validate event limits before recording step event
     await ctx.validate_event_limits()
 

pyworkflow/storage/base.py

@@ -358,6 +358,35 @@ class StorageBackend(ABC):
         """
         pass
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """
+        Atomically transition run status if the current status matches.
+
+        This is a compare-and-swap operation: the status is only updated
+        if the current status equals `from_status`. Returns True if the
+        transition was applied, False if the current status did not match
+        (meaning another task already claimed this run).
+
+        Args:
+            run_id: Workflow run identifier
+            from_status: Expected current status
+            to_status: New status to set
+
+        Returns:
+            True if the transition succeeded, False otherwise
+        """
+        # Default implementation using get_run + update_run_status.
+        # Backends should override with truly atomic implementations.
+        run = await self.get_run(run_id)
+        if not run or run.status != from_status:
+            return False
+        await self.update_run_status(run_id, to_status)
+        return True
+
     # Cancellation Flag Operations
 
     @abstractmethod

pyworkflow/storage/cassandra.py

@@ -1209,6 +1209,31 @@ class CassandraStorageBackend(StorageBackend):
         # Apply offset and limit
         return hooks[offset : offset + limit]
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """Atomically transition run status using lightweight transaction (IF)."""
+        session = self._ensure_connected()
+
+        result = session.execute(
+            SimpleStatement(
+                """
+                UPDATE workflow_runs
+                SET status = %s, updated_at = %s
+                WHERE run_id = %s
+                IF status = %s
+                """,
+                consistency_level=ConsistencyLevel.SERIAL,
+            ),
+            (to_status.value, datetime.now(UTC), run_id, from_status.value),
+        )
+
+        # Cassandra LWT returns [applied] column
+        row = result.one()
+        return row is not None and row[0] is True
+
     # Cancellation Flag Operations
 
     async def set_cancellation_flag(self, run_id: str) -> None:

pyworkflow/storage/dynamodb.py

@@ -889,6 +889,37 @@ class DynamoDBStorageBackend(StorageBackend):
 
             return [self._item_to_hook(self._item_to_dict(item)) for item in items]
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """Atomically transition run status using conditional update."""
+        async with self._get_client() as client:
+            try:
+                now = datetime.now(UTC).isoformat()
+                await client.update_item(
+                    TableName=self.table_name,
+                    Key={
+                        "PK": {"S": f"RUN#{run_id}"},
+                        "SK": {"S": "#METADATA"},
+                    },
+                    UpdateExpression="SET #status = :new_status, updated_at = :now, GSI1SK = :gsi1sk",
+                    ConditionExpression="#status = :expected_status",
+                    ExpressionAttributeNames={"#status": "status"},
+                    ExpressionAttributeValues={
+                        ":new_status": {"S": to_status.value},
+                        ":expected_status": {"S": from_status.value},
+                        ":now": {"S": now},
+                        ":gsi1sk": {"S": f"{to_status.value}#{now}"},
+                    },
+                )
+                return True
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "ConditionalCheckFailedException":
+                    return False
+                raise
+
     # Cancellation Flag Operations
 
     async def set_cancellation_flag(self, run_id: str) -> None:

pyworkflow/storage/file.py

@@ -592,6 +592,34 @@ class FileStorageBackend(StorageBackend):
         hook_data_list = await asyncio.to_thread(_list)
         return [Hook.from_dict(data) for data in hook_data_list]
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """Atomically transition run status using file lock."""
+        run_file = self.runs_dir / f"{run_id}.json"
+
+        if not run_file.exists():
+            return False
+
+        lock_file = self.locks_dir / f"{run_id}.lock"
+        lock = FileLock(str(lock_file))
+
+        def _try_claim() -> bool:
+            with lock:
+                if not run_file.exists():
+                    return False
+                data = json.loads(run_file.read_text())
+                if data.get("status") != from_status.value:
+                    return False
+                data["status"] = to_status.value
+                data["updated_at"] = datetime.now(UTC).isoformat()
+                run_file.write_text(json.dumps(data, indent=2))
+                return True
+
+        return await asyncio.to_thread(_try_claim)
+
     # Cancellation Flag Operations
 
     async def set_cancellation_flag(self, run_id: str) -> None:

pyworkflow/storage/memory.py

@@ -366,6 +366,20 @@ class InMemoryStorageBackend(StorageBackend):
             # Apply pagination
             return hooks[offset : offset + limit]
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """Atomically transition run status using lock-protected check-and-set."""
+        with self._lock:
+            run = self._runs.get(run_id)
+            if not run or run.status != from_status:
+                return False
+            run.status = to_status
+            run.updated_at = datetime.now(UTC)
+            return True
+
     # Cancellation Flag Operations
 
     async def set_cancellation_flag(self, run_id: str) -> None:

pyworkflow/storage/mysql.py

@@ -767,6 +767,26 @@ class MySQLStorageBackend(StorageBackend):
 
         return [self._row_to_hook(row) for row in rows]
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """Atomically transition run status using conditional UPDATE."""
+        pool = self._ensure_connected()
+
+        async with pool.acquire() as conn, conn.cursor() as cur:
+            await cur.execute(
+                """
+                UPDATE workflow_runs
+                SET status = %s, updated_at = %s
+                WHERE run_id = %s AND status = %s
+                """,
+                (to_status.value, datetime.now(UTC), run_id, from_status.value),
+            )
+
+            return cur.rowcount > 0
+
     # Cancellation Flag Operations
 
     async def set_cancellation_flag(self, run_id: str) -> None:

pyworkflow/storage/postgres.py

@@ -862,6 +862,30 @@ class PostgresStorageBackend(StorageBackend):
 
         return [self._row_to_hook(row) for row in rows]
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """Atomically transition run status using conditional UPDATE."""
+        pool = await self._get_pool()
+
+        async with pool.acquire() as conn:
+            result = await conn.execute(
+                """
+                UPDATE workflow_runs
+                SET status = $1, updated_at = $2
+                WHERE run_id = $3 AND status = $4
+                """,
+                to_status.value,
+                datetime.now(UTC),
+                run_id,
+                from_status.value,
+            )
+
+        # asyncpg returns 'UPDATE N' where N is rows affected
+        return result == "UPDATE 1"
+
     # Cancellation Flag Operations
 
     async def set_cancellation_flag(self, run_id: str) -> None:

pyworkflow/storage/sqlite.py

@@ -750,6 +750,26 @@ class SQLiteStorageBackend(StorageBackend):
 
         return [self._row_to_hook(row) for row in rows]
 
+    # Atomic Status Transition
+
+    async def try_claim_run(
+        self, run_id: str, from_status: RunStatus, to_status: RunStatus
+    ) -> bool:
+        """Atomically transition run status using conditional UPDATE."""
+        db = self._ensure_connected()
+
+        cursor = await db.execute(
+            """
+            UPDATE workflow_runs
+            SET status = ?, updated_at = ?
+            WHERE run_id = ? AND status = ?
+            """,
+            (to_status.value, datetime.now(UTC).isoformat(), run_id, from_status.value),
+        )
+        await db.commit()
+
+        return cursor.rowcount > 0
+
     # Cancellation Flag Operations
 
     async def set_cancellation_flag(self, run_id: str) -> None:

{pyworkflow_engine-0.1.20.dist-info → pyworkflow_engine-0.1.22.dist-info}/METADATA

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

{pyworkflow_engine-0.1.20.dist-info → pyworkflow_engine-0.1.22.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyworkflow/__init__.py,sha256=hvr-rmg5k0kCiTaH29Y-ukxFGMt_Az-mn_Oi3qZGkaA,6281
+pyworkflow/__init__.py,sha256=HigyYErtUxyfrsBOPEUvegnsLnqnwfrBm87EEzfYtOI,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
@@ -10,7 +10,7 @@ pyworkflow/celery/app.py,sha256=QXpPXVVuwJv3ToylT0pyz9SgmwjC9hW-9WaIO4wH5OQ,1434
 pyworkflow/celery/loop.py,sha256=mu8cIfMJYgHAoGCN_DdDoNoXK3QHzHpLmrPCyFDQYIY,3016
 pyworkflow/celery/scheduler.py,sha256=Ms4rqRpdpMiLM8l4y3DK-Divunj9afYuUaGGoNQe7P4,11288
 pyworkflow/celery/singleton.py,sha256=9gdVHzqFjShZ9OJOJlJNABUg9oqnl6ITGROtomcOtsg,16070
-pyworkflow/celery/tasks.py,sha256=uUfV6aGerd2mTIw11TX5zgFE6DpqQnmaqUASSw4ap3g,86293
+pyworkflow/celery/tasks.py,sha256=0doKC7JxGlU4QFShohQn9NRgiOybfLrBm6j81C8m3dc,88482
 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
@@ -43,7 +43,7 @@ pyworkflow/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyworkflow/core/exceptions.py,sha256=rL0SlRWymoLItOdbcbfMnAysq5F0IjmAls2CzzI6AWE,10725
 pyworkflow/core/registry.py,sha256=ZUf2YTpBvWpC9EehRbMF8soXOk9VsjNruoi6lR4O33M,9361
 pyworkflow/core/scheduled.py,sha256=479A7IvjHiMob7ZrZtfE6VqtypG6DLIGMGhh16jLIWM,10522
-pyworkflow/core/step.py,sha256=Ez4-nEASR9bUkHAFN3GCkrDo9Nx_aiwyPXqaEVTYp6Q,23925
+pyworkflow/core/step.py,sha256=tq2dc_gflAy4FVhanfPT9oHP8Mzxx1szaNc6m4pmAj0,24745
 pyworkflow/core/validation.py,sha256=0VaZyQ9YGK8WFy4ZG4Bjt9MYAp0vz6xEOe80kcgaP5g,3362
 pyworkflow/core/workflow.py,sha256=tBRMRYBmQZoCWjVEXDT4W-4VZLG6q-iRFqC-_qZW-Uc,12309
 pyworkflow/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -73,22 +73,22 @@ pyworkflow/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 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=ZS0jTdBRmT4nhADIPpr_MmOvqQvhse3LSb6CDt5rr-4,16324
-pyworkflow/storage/cassandra.py,sha256=DTJJr4yqAV-941YjQQdoO1-5SsFoqke82sXpBrXPyKg,61741
+pyworkflow/storage/base.py,sha256=4rPBrmRpxkZFNjmxOl7e5B8hVJ6kRM3XPCH_qgA1hFI,17404
+pyworkflow/storage/cassandra.py,sha256=wevLXyx8WHya1QafnY5YUurvveyM2F2EEilD_G6RM_U,62560
 pyworkflow/storage/config.py,sha256=45UMPxRoqgK4ZwE7HIK9ctxE_eoK3eAE_1tRhn3Psd4,12410
-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/dynamodb.py,sha256=_X2Ijj3lEaOYfuYSdf6y4uhZBXHMovZOUS9XFuCz3Uk,55523
+pyworkflow/storage/file.py,sha256=7CiEQ6lhRXAyUr_tEG_G4OxqllcHaGu0353v_9de-DU,31095
+pyworkflow/storage/memory.py,sha256=YiA3n0BX7UOcgOkXxCtm7U3GTC5SlzUCrHIANSwoI7c,21040
+pyworkflow/storage/mysql.py,sha256=bQyyu1-SqjTaGcV4woh3sr2bz_TrftCvoTXuVOQZq1A,44432
+pyworkflow/storage/postgres.py,sha256=ZbPyT3-s7jCDLpTZe4CJYCtU1VQgldIcq4wl1hjFRAU,46113
 pyworkflow/storage/schemas.py,sha256=o1ntTYNgQQ5YVuXtPCShtENEsndVjdrXclWrkCgkitg,18002
-pyworkflow/storage/sqlite.py,sha256=qDhFjyFAenwYq6MF_66FFhDaBG7CEr7ni9Uy72X7MvQ,40377
+pyworkflow/storage/sqlite.py,sha256=h48FOGtsHHglIEe4hBkf_vR41pwumDDATGsz7-u3wQA,40987
 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.20.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
-pyworkflow_engine-0.1.20.dist-info/METADATA,sha256=PBMGEdZ0oBXLKccvpM2NNVB9K6sjJOuc1LvqwKSt82A,19628
-pyworkflow_engine-0.1.20.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyworkflow_engine-0.1.20.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
-pyworkflow_engine-0.1.20.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
-pyworkflow_engine-0.1.20.dist-info/RECORD,,
+pyworkflow_engine-0.1.22.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
+pyworkflow_engine-0.1.22.dist-info/METADATA,sha256=vulOQGFZqTd-TJ3fjgTY1JQBB942bJr97aw7bHs3jTA,19628
+pyworkflow_engine-0.1.22.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyworkflow_engine-0.1.22.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
+pyworkflow_engine-0.1.22.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
+pyworkflow_engine-0.1.22.dist-info/RECORD,,