pyworkflow-engine 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

pyworkflow/__init__.py

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

pyworkflow/aws/context.py

@@ -209,7 +209,7 @@ class AWSWorkflowContext(WorkflowContext):
         """Request cancellation (AWS manages this internally)."""
         logger.warning("Cancellation not supported in AWS context")
 
-    def check_cancellation(self) -> None:
+    async def check_cancellation(self) -> None:
         """Check cancellation (AWS manages this internally)."""
         pass  # AWS handles this
 

pyworkflow/celery/tasks.py

@@ -207,6 +207,9 @@ def execute_step_task(
             context_class = _resolve_context_class(context_class_name)
             if context_class is not None:
                 step_ctx = context_class.from_dict(context_data)
+                # Inject cancellation metadata so check_cancellation() works on workers
+                object.__setattr__(step_ctx, "_cancellation_run_id", run_id)
+                object.__setattr__(step_ctx, "_cancellation_storage", storage)
                 step_context_token = _set_step_context_internal(step_ctx)
                 # Set readonly mode to prevent mutation in steps
                 readonly_token = _set_step_context_readonly(True)

pyworkflow/context/base.py

@@ -239,12 +239,15 @@ class WorkflowContext(ABC):
         ...
 
     @abstractmethod
-    def check_cancellation(self) -> None:
+    async def check_cancellation(self) -> None:
         """
         Check for cancellation and raise if requested.
 
         This should be called at interruptible points (before steps,
-        during sleeps, etc.) to allow graceful cancellation.
+        during sleeps, etc.) to allow graceful cancellation. In durable
+        mode, this also checks the storage backend's cancellation flag
+        to detect external cancellation requests (e.g., from
+        ``cancel_workflow()``).
 
         Raises:
             CancellationError: If cancellation was requested and not blocked

pyworkflow/context/local.py

@@ -744,7 +744,7 @@ class LocalContext(WorkflowContext):
             return
 
         # Check for cancellation before sleeping
-        self.check_cancellation()
+        await self.check_cancellation()
 
         # Durable mode - suspend workflow
         sleep_id = self._generate_sleep_id(duration_seconds)
@@ -913,7 +913,7 @@ class LocalContext(WorkflowContext):
             )
 
         # Check for cancellation before waiting for hook
-        self.check_cancellation()
+        await self.check_cancellation()
 
         # Generate deterministic hook_id
         self._step_counter += 1
@@ -1038,19 +1038,22 @@ class LocalContext(WorkflowContext):
             reason=reason,
         )
 
-    def check_cancellation(self) -> None:
+    async def check_cancellation(self) -> None:
         """
         Check for cancellation and raise if requested.
 
         This should be called at interruptible points (before steps,
-        during sleeps, etc.) to allow graceful cancellation.
+        during sleeps, etc.) to allow graceful cancellation. In durable
+        mode, this also queries the storage backend to detect external
+        cancellation requests (e.g., from ``cancel_workflow()``).
 
         Raises:
             CancellationError: If cancellation was requested and not blocked
         """
-        if self._cancellation_requested and not self._cancellation_blocked:
-            from pyworkflow.core.exceptions import CancellationError
+        from pyworkflow.core.exceptions import CancellationError
 
+        # Fast path: in-memory flag
+        if self._cancellation_requested and not self._cancellation_blocked:
             logger.info(
                 "Cancellation check triggered - raising CancellationError",
                 run_id=self._run_id,
@@ -1061,6 +1064,27 @@ class LocalContext(WorkflowContext):
                 reason=self._cancellation_reason,
             )
 
+        # Storage check: detect external cancellation (durable mode only)
+        if not self._cancellation_blocked and self._durable and self._storage is not None:
+            try:
+                if await self._storage.check_cancellation_flag(self._run_id):
+                    self._cancellation_requested = True
+                    logger.info(
+                        "Cancellation detected via storage flag - raising CancellationError",
+                        run_id=self._run_id,
+                    )
+                    raise CancellationError(
+                        message="Workflow was cancelled: detected via storage flag",
+                        reason=self._cancellation_reason,
+                    )
+            except CancellationError:
+                raise
+            except Exception as e:
+                logger.warning(
+                    f"Failed to check cancellation flag in storage: {e}",
+                    run_id=self._run_id,
+                )
+
     @property
     def cancellation_blocked(self) -> bool:
         """

pyworkflow/context/mock.py

@@ -322,7 +322,7 @@ class MockContext(WorkflowContext):
         self._cancellation_requested = True
         self._cancellation_reason = reason
 
-    def check_cancellation(self) -> None:
+    async def check_cancellation(self) -> None:
         """Check if cancellation was requested and raise if not blocked."""
         from pyworkflow.core.exceptions import CancellationError
 

pyworkflow/context/step_context.py

@@ -47,11 +47,17 @@ Usage:
         return {"valid": True}
 """
 
+from __future__ import annotations
+
 from contextvars import ContextVar, Token
-from typing import Any, Self
+from typing import TYPE_CHECKING, Any, Self
 
+from loguru import logger
 from pydantic import BaseModel, ConfigDict
 
+if TYPE_CHECKING:
+    from pyworkflow.storage.base import StorageBackend
+
 
 class StepContext(BaseModel):
     """
@@ -80,6 +86,61 @@ class StepContext(BaseModel):
 
     model_config = ConfigDict(frozen=True, extra="forbid")
 
+    # Private attributes injected by the framework (not serialized).
+    # These enable check_cancellation() to work even when WorkflowContext
+    # is not available (e.g., on Celery workers, inside LangGraph tools).
+    _cancellation_run_id: str | None = None
+    _cancellation_storage: StorageBackend | None = None
+
+    async def check_cancellation(self) -> None:
+        """
+        Check for cancellation and raise CancellationError if requested.
+
+        This works in all execution contexts:
+        - If a WorkflowContext is available, delegates to it (checks both
+          in-memory flag and storage).
+        - Otherwise, checks the storage cancellation flag directly using
+          the run_id and storage injected by the framework.
+
+        This is especially useful for long-running operations inside steps
+        or tool adapters where WorkflowContext may not be available (e.g.,
+        on Celery workers, inside LangGraph tool execution).
+
+        Raises:
+            CancellationError: If cancellation was requested
+
+        Example:
+            @step()
+            async def long_running_step():
+                ctx = get_step_context()
+                for chunk in chunks:
+                    await ctx.check_cancellation()
+                    await process(chunk)
+        """
+        from pyworkflow.context import get_context, has_context
+        from pyworkflow.core.exceptions import CancellationError
+
+        # Fast path: delegate to WorkflowContext if available
+        if has_context():
+            await get_context().check_cancellation()
+            return
+
+        # Fallback: check storage flag directly
+        if self._cancellation_run_id is not None and self._cancellation_storage is not None:
+            try:
+                if await self._cancellation_storage.check_cancellation_flag(
+                    self._cancellation_run_id
+                ):
+                    raise CancellationError(
+                        message="Workflow was cancelled: detected via storage flag",
+                    )
+            except CancellationError:
+                raise
+            except Exception as e:
+                logger.warning(
+                    f"Failed to check cancellation flag in storage: {e}",
+                )
+
     def with_updates(self: Self, **kwargs: Any) -> Self:
         """
         Create a new context with updated values.
@@ -203,12 +264,21 @@ async def set_step_context(ctx: StepContext) -> None:
     if not isinstance(ctx, StepContext):
         raise TypeError(f"Expected StepContext instance, got {type(ctx).__name__}")
 
+    # Inject cancellation metadata from WorkflowContext if available.
+    # This enables check_cancellation() to work even when WorkflowContext
+    # is not accessible (e.g., on Celery workers, inside LangGraph tools).
+    from pyworkflow.context import get_context, has_context
+
+    if has_context():
+        workflow_ctx = get_context()
+        object.__setattr__(ctx, "_cancellation_run_id", workflow_ctx.run_id)
+        if workflow_ctx.is_durable and workflow_ctx.storage is not None:
+            object.__setattr__(ctx, "_cancellation_storage", workflow_ctx.storage)
+
     # Set the context in the contextvar
     _step_context.set(ctx)
 
     # Persist to storage if we're in a durable workflow
-    from pyworkflow.context import get_context, has_context
-
     if has_context():
         workflow_ctx = get_context()
         if workflow_ctx.is_durable and workflow_ctx.storage is not None:

pyworkflow/core/exceptions.py

@@ -47,7 +47,7 @@ class CancellationError(WorkflowError):
     Note:
         CancellationError is raised at checkpoint boundaries (before steps,
         sleeps, hooks), not during step execution. Long-running steps can
-        call ``ctx.check_cancellation()`` for cooperative cancellation.
+        call ``await ctx.check_cancellation()`` for cooperative cancellation.
 
     Example:
         @workflow

pyworkflow/core/step.py

@@ -110,7 +110,7 @@ def step(
             ctx = get_context()
 
             # Check for cancellation before executing step
-            ctx.check_cancellation()
+            await ctx.check_cancellation()
 
             # Transient mode: execute directly without event sourcing
             # Retries are still supported via direct execution
@@ -243,7 +243,7 @@ def step(
             )
 
             # Check for cancellation before executing step
-            ctx.check_cancellation()
+            await ctx.check_cancellation()
 
             # Validate parameters before execution
             validate_step_parameters(func, args, kwargs, step_name)

pyworkflow/core/workflow.py

@@ -233,6 +233,9 @@ async def execute_workflow_with_context(
             context_data = await storage.get_run_context(run_id)
             if context_data:
                 step_ctx = context_class.from_dict(context_data)
+                # Inject cancellation metadata so check_cancellation() works
+                object.__setattr__(step_ctx, "_cancellation_run_id", run_id)
+                object.__setattr__(step_ctx, "_cancellation_storage", storage)
                 step_context_token = _set_step_context_internal(step_ctx)
 
     try:

pyworkflow/engine/executor.py

@@ -566,7 +566,7 @@ async def cancel_workflow(
         Cancellation does NOT interrupt a step that is already executing.
         If a step takes a long time, cancellation will only be detected after
         the step completes. For long-running steps that need mid-execution
-        cancellation, call ``ctx.check_cancellation()`` periodically within
+        cancellation, call ``await ctx.check_cancellation()`` periodically within
         the step function.
 
     Args:
@@ -649,9 +649,14 @@ async def cancel_workflow(
         current_status=run.status.value,
     )
 
+    # Always set the cancellation flag in storage so that distributed
+    # components (Celery workers, LangGraph tools, StepContext.check_cancellation())
+    # can detect the cancellation regardless of workflow status.
+    await storage.set_cancellation_flag(run_id)
+
     # Handle based on current status
     if run.status == RunStatus.SUSPENDED:
-        # For suspended workflows, update status to CANCELLED immediately
+        # For suspended workflows, also update status to CANCELLED immediately
         # The workflow will see cancellation when it tries to resume
         cancelled_event = create_workflow_cancelled_event(
             run_id=run_id,
@@ -667,10 +672,6 @@ async def cancel_workflow(
         )
 
     elif run.status in {RunStatus.RUNNING, RunStatus.PENDING}:
-        # For running/pending workflows, set cancellation flag
-        # The workflow will detect this at the next check point
-        await storage.set_cancellation_flag(run_id)
-
         logger.info(
             "Cancellation flag set for running workflow",
             run_id=run_id,

pyworkflow/primitives/child_workflow.py

@@ -98,7 +98,7 @@ async def start_child_workflow(
         )
 
     # Check for cancellation before starting child
-    ctx.check_cancellation()
+    await ctx.check_cancellation()
 
     # Get workflow metadata
     workflow_meta = get_workflow_by_func(workflow_func)

pyworkflow/primitives/continue_as_new.py

@@ -14,7 +14,7 @@ from pyworkflow.context import get_context, has_context
 from pyworkflow.core.exceptions import ContinueAsNewSignal
 
 
-def continue_as_new(*args: Any, **kwargs: Any) -> NoReturn:
+async def continue_as_new(*args: Any, **kwargs: Any) -> NoReturn:
     """
     Complete current workflow and start a new execution with fresh event history.
 
@@ -48,7 +48,7 @@ def continue_as_new(*args: Any, **kwargs: Any) -> NoReturn:
 
             # Continue with new cursor if more items
             if new_cursor:
-                continue_as_new(cursor=new_cursor)
+                await continue_as_new(cursor=new_cursor)
 
             return "done"
 
@@ -59,7 +59,7 @@ def continue_as_new(*args: Any, **kwargs: Any) -> NoReturn:
 
             # Continue with next day
             next_date = get_next_date(date)
-            continue_as_new(date=next_date)
+            await continue_as_new(date=next_date)
 
         @workflow
         async def batch_processor(offset: int = 0, batch_size: int = 100):
@@ -69,7 +69,7 @@ def continue_as_new(*args: Any, **kwargs: Any) -> NoReturn:
                 for item in items:
                     await process_item(item)
                 # Continue with next batch
-                continue_as_new(offset=offset + batch_size, batch_size=batch_size)
+                await continue_as_new(offset=offset + batch_size, batch_size=batch_size)
 
             return f"Processed {offset} items total"
     """
@@ -88,7 +88,7 @@ def continue_as_new(*args: Any, **kwargs: Any) -> NoReturn:
     ctx = get_context()
 
     # Check for cancellation - don't continue if cancelled
-    ctx.check_cancellation()
+    await ctx.check_cancellation()
 
     logger.info(
         "Workflow continuing as new execution",

pyworkflow/primitives/shield.py

@@ -15,7 +15,7 @@ Note:
     Cancellation does NOT interrupt a step mid-execution. If a step takes
     a long time, cancellation will only be detected after it completes.
     For cooperative cancellation within long-running steps, call
-    ``ctx.check_cancellation()`` periodically.
+    ``await ctx.check_cancellation()`` periodically.
 
 Example:
     @workflow

{pyworkflow_engine-0.1.17.dist-info → pyworkflow_engine-0.1.19.dist-info}/METADATA

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

{pyworkflow_engine-0.1.17.dist-info → pyworkflow_engine-0.1.19.dist-info}/RECORD

@@ -1,8 +1,8 @@
-pyworkflow/__init__.py,sha256=IDkVaqj1HNXn5kLqUGlLetTFpM_moNQdvCZS2aPQdR8,6281
+pyworkflow/__init__.py,sha256=f5YtGeV9RATqNziHuyUJVPHhg2LVzqWDuwNL3bqdtAI,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
-pyworkflow/aws/context.py,sha256=Vjyjip6U1Emg-WA5TlBaxFhcg15rf9mVJiPfT4VywHc,8217
+pyworkflow/aws/context.py,sha256=C_wBr_YRUYT4IHyaAGPdiqRPNbH8mDLkoMpVtQVIg28,8223
 pyworkflow/aws/handler.py,sha256=0SnQuIfQVD99QKMCRFPtrsrV_l1LYKFkzPIRx_2UkSI,5849
 pyworkflow/aws/testing.py,sha256=WrRk9wjbycM-UyHFQWNnA83UE9IrYnhfT38WrbxQT2U,8844
 pyworkflow/celery/__init__.py,sha256=FywVyqnT8AYz9cXkr-wel7_-N7dHFsPNASEPMFESf4Q,1179
@@ -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=BNHZwWTSRc3q8EgAy4tEmXAm6O0vtVLgrG7MrO0ZZXA,86049
+pyworkflow/celery/tasks.py,sha256=uUfV6aGerd2mTIw11TX5zgFE6DpqQnmaqUASSw4ap3g,86293
 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
@@ -35,32 +35,32 @@ pyworkflow/cli/utils/interactive.py,sha256=S2Ell-rUzzt3V10diGo5XCgiDcYFYSxoXNYkJ
 pyworkflow/cli/utils/storage.py,sha256=a5Iu2Xe1_mPgBVYc8B6I63MFfW12ko7wURqcpq3RBPA,4018
 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=eKBF-e_WSkVIqbynVysQy6rH02rXmPts29KtjY41IQI,38853
-pyworkflow/context/mock.py,sha256=TJzQ3P3_ZHm1lCJZJACIFFvz2ydFxz2cT9eEGOQS5I0,12061
-pyworkflow/context/step_context.py,sha256=6P2jn1v7MTlYaWCTt6DBq7Nkmxm7nvna4oGpTZJeMbg,8862
+pyworkflow/context/base.py,sha256=uCKpXnRUON9EgAk8miUl06tDVpmLe1dZ_7FhwCO8lE0,13953
+pyworkflow/context/local.py,sha256=qjsmLE7pzw_OUcrPSzrbNBCPuMDZ8DR9USDqki7RcCA,40032
+pyworkflow/context/mock.py,sha256=tPB0KIWsMRlUjgteWdLKyJcX5U8tHajLCkolVGFbJxc,12067
+pyworkflow/context/step_context.py,sha256=Ufp1Mu0sX5i2reWEALHnlN7U7XIcyqjqZtgWaJpc-Vc,11785
 pyworkflow/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyworkflow/core/exceptions.py,sha256=F2nbXyoed7wlIJMeGfpgsIC8ZyWcYN0iKtOnBA7-xnQ,10719
+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=9JG9udEDph_6ecfruVdY0qC3ruoC6bjd0F91chg8QZM,23913
+pyworkflow/core/step.py,sha256=Ez4-nEASR9bUkHAFN3GCkrDo9Nx_aiwyPXqaEVTYp6Q,23925
 pyworkflow/core/validation.py,sha256=0VaZyQ9YGK8WFy4ZG4Bjt9MYAp0vz6xEOe80kcgaP5g,3362
-pyworkflow/core/workflow.py,sha256=dlcICq1B69-nxUJth_n-H8U9TjP3QZyjvquQXxWHcxs,12076
+pyworkflow/core/workflow.py,sha256=tBRMRYBmQZoCWjVEXDT4W-4VZLG6q-iRFqC-_qZW-Uc,12309
 pyworkflow/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyworkflow/engine/events.py,sha256=KFtyIqQjr1B9Frtd5V1Zq0ph1iwg_Ky3uPzmTYZ1Tnk,25827
-pyworkflow/engine/executor.py,sha256=l2HlpQfqzSL_0WuTFb1c4pEIgYU9JcN792hkGICqCAk,21109
+pyworkflow/engine/executor.py,sha256=oTG8ZGAlbCHxuEPuXxjyyGRAvF9oUdm9qe1I-fh67xQ,21209
 pyworkflow/engine/replay.py,sha256=bmMb4wzPKaZwPOage3Z-g_5DndYNoSmavMZ9sPiFzYI,9386
 pyworkflow/observability/__init__.py,sha256=M_Uc3WdtshQSxLnj3T8D0M7f4zcCuFzVs8e8PKCuXDc,380
 pyworkflow/observability/logging.py,sha256=4WYR188z8NppWWpgsUkkJfBLWZp5St6ro3i7DJq4LP4,8803
 pyworkflow/primitives/__init__.py,sha256=rEahSVLhG3nSxvcRhJeM1LBSBIV7AkcRTnxuMLmZMTM,1041
 pyworkflow/primitives/child_handle.py,sha256=7NcIaNUQdZEoxmk5gQH1CJ6uQzpro3eFo-sEaM6l6w0,5466
-pyworkflow/primitives/child_workflow.py,sha256=_T7PCqiH0tjIm_lpJ6NmfUPWCFx-MjH6t-C1orwohKs,13134
-pyworkflow/primitives/continue_as_new.py,sha256=NKcimHsgr5ExkvRvfO28hxgPw_I7Q74Vz9WL8r0PhPc,3329
+pyworkflow/primitives/child_workflow.py,sha256=s1DGqdpvyGMqzeBbd7HKnZ0UW__VyexUGJN_8hRq05w,13140
+pyworkflow/primitives/continue_as_new.py,sha256=YGAAsjEY6DgGMZSDftw9Y_ml2nlwCfIVEjbjC0rrBOQ,3359
 pyworkflow/primitives/define_hook.py,sha256=gNzk7DuObfWG1T9AdHnDnGLHNKjnApiVRlCKPObugfY,4443
 pyworkflow/primitives/hooks.py,sha256=ws9U81ymsY8M4FFTvJ2X4EMGmIrilb3vCKZ0V_EGZdE,3085
 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/shield.py,sha256=aRlW_Guwv6P1rvZS9dVidlevIKGRqRMSruoG018vHRs,2930
 pyworkflow/primitives/sleep.py,sha256=iH1e5CoWY-jZbYNAU3GRW1xR_8EtCuPIcIohzU4jWJo,3097
 pyworkflow/runtime/__init__.py,sha256=DkwTgFCMRGyyW8NGcW7Nyy9beOg5kO1TXhqhysj1-aY,649
 pyworkflow/runtime/base.py,sha256=ATlPeheYzUMlk_v-9abLyUQf4y4iYB53VpaoQ73pYsc,5465
@@ -86,9 +86,9 @@ pyworkflow/storage/sqlite.py,sha256=qDhFjyFAenwYq6MF_66FFhDaBG7CEr7ni9Uy72X7MvQ,
 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.17.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
-pyworkflow_engine-0.1.17.dist-info/METADATA,sha256=UGSPGJCOnw56WxwhgnC9-Tb29GvC7WZIxEBGymjSDh8,19628
-pyworkflow_engine-0.1.17.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyworkflow_engine-0.1.17.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
-pyworkflow_engine-0.1.17.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
-pyworkflow_engine-0.1.17.dist-info/RECORD,,
+pyworkflow_engine-0.1.19.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
+pyworkflow_engine-0.1.19.dist-info/METADATA,sha256=ZLi6b7vK2sLOgq20OBvMfjXHwyOx70Vai19f2Essj4Q,19628
+pyworkflow_engine-0.1.19.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyworkflow_engine-0.1.19.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
+pyworkflow_engine-0.1.19.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
+pyworkflow_engine-0.1.19.dist-info/RECORD,,