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

pyworkflow/__init__.py

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

pyworkflow/celery/app.py

@@ -194,6 +194,16 @@ def create_celery_app(
         worker_task_log_format="[%(asctime)s: %(levelname)s/%(processName)s] [%(task_name)s(%(task_id)s)] %(message)s",
     )
 
+    # Configure singleton locking for Redis brokers
+    # This enables distributed locking to prevent duplicate task execution
+    is_redis_broker = broker_url.startswith("redis://") or broker_url.startswith("rediss://")
+    if is_redis_broker:
+        app.conf.update(
+            singleton_backend_url=broker_url,
+            singleton_key_prefix="pyworkflow:lock:",
+            singleton_lock_expiry=3600,  # 1 hour TTL (safety net)
+        )
+
     # Note: Logging is configured via Celery signals (worker_init, worker_process_init)
     # to ensure proper initialization AFTER process forking.
     # See on_worker_init() and on_worker_process_init() below.

pyworkflow/celery/singleton.py

@@ -0,0 +1,368 @@
+"""
+Singleton task implementation for PyWorkflow.
+
+Provides Redis-based distributed locking to prevent duplicate task execution.
+Self-contained implementation (no external dependencies beyond redis).
+
+Based on:
+- steinitzu/celery-singleton library concepts
+- FlowHunt's battle-tested refinements for retry-safe lock management
+"""
+
+import inspect
+import json
+from hashlib import md5
+from typing import Any
+from uuid import uuid4
+
+from celery import Task
+from celery.exceptions import WorkerLostError
+from loguru import logger
+
+
+def generate_lock_key(
+    task_name: str,
+    task_args: list[Any] | tuple[Any, ...] | None = None,
+    task_kwargs: dict[str, Any] | None = None,
+    key_prefix: str = "pyworkflow:lock:",
+) -> str:
+    """
+    Generate a unique lock key for a task based on its name and arguments.
+
+    Uses MD5 hash to keep key length reasonable while ensuring uniqueness.
+    """
+    str_args = json.dumps(task_args or [], sort_keys=True, default=str)
+    str_kwargs = json.dumps(task_kwargs or {}, sort_keys=True, default=str)
+    task_hash = md5((task_name + str_args + str_kwargs).encode()).hexdigest()
+    return key_prefix + task_hash
+
+
+class SingletonConfig:
+    """Configuration for singleton task behavior."""
+
+    def __init__(self, app: Any):
+        self.app = app
+
+    @property
+    def backend_url(self) -> str | None:
+        return self.app.conf.get("singleton_backend_url")
+
+    @property
+    def key_prefix(self) -> str:
+        return self.app.conf.get("singleton_key_prefix", "pyworkflow:lock:")
+
+    @property
+    def lock_expiry(self) -> int:
+        return self.app.conf.get("singleton_lock_expiry", 3600)
+
+    @property
+    def raise_on_duplicate(self) -> bool:
+        return self.app.conf.get("singleton_raise_on_duplicate", False)
+
+
+class RedisLockBackend:
+    """Redis backend for distributed locking."""
+
+    def __init__(self, url: str):
+        import redis
+
+        self.redis = redis.from_url(url, decode_responses=True)
+
+    def lock(self, lock_key: str, task_id: str, expiry: int | None = None) -> bool:
+        """Acquire lock atomically. Returns True if acquired."""
+        return bool(self.redis.set(lock_key, task_id, nx=True, ex=expiry))
+
+    def unlock(self, lock_key: str) -> None:
+        """Release the lock."""
+        self.redis.delete(lock_key)
+
+    def get(self, lock_key: str) -> str | None:
+        """Get the task ID holding the lock."""
+        return self.redis.get(lock_key)
+
+
+class DuplicateTaskError(Exception):
+    """Raised when attempting to queue a duplicate singleton task."""
+
+    def __init__(self, message: str, task_id: str):
+        self.task_id = task_id
+        super().__init__(message)
+
+
+class SingletonWorkflowTask(Task):
+    """
+    Base class for singleton workflow tasks with distributed locking.
+
+    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)
+    - Lock released on success or when max retries exceeded
+    - Time-based lock expiry as safety net
+
+    Configuration:
+        unique_on: List of argument names to use for uniqueness (e.g., ["run_id", "step_id"])
+                   Supports nested access with dot notation (e.g., ["data.run_id"])
+        raise_on_duplicate: If True, raise DuplicateTaskError instead of returning existing result
+        lock_expiry: Lock TTL in seconds (default: 3600 = 1 hour)
+
+    Example:
+        @celery_app.task(
+            base=SingletonWorkflowTask,
+            unique_on=["run_id", "step_id"],
+        )
+        def my_task(run_id: str, step_id: str, data: dict):
+            ...
+    """
+
+    abstract = True
+
+    # Singleton configuration (can be overridden per-task)
+    unique_on: list[str] | str | None = None
+    raise_on_duplicate: bool | None = None
+    lock_expiry: int | None = None
+
+    # Lock behavior
+    release_lock_on_success: bool = True
+    release_lock_on_failure: bool = False  # Keep lock during retries
+
+    # Celery task settings
+    max_retries: int | None = None
+    acks_on_failure_or_timeout: bool = True
+
+    # Cached instances (class-level, shared across task instances)
+    _singleton_backend: RedisLockBackend | None = None
+    _singleton_config: SingletonConfig | None = None
+
+    @property
+    def singleton_config(self) -> SingletonConfig:
+        if self._singleton_config is None:
+            self._singleton_config = SingletonConfig(self.app)
+        return self._singleton_config
+
+    @property
+    def singleton_backend(self) -> RedisLockBackend | None:
+        if self._singleton_backend is None:
+            url = self.singleton_config.backend_url
+            if not url:
+                # Try broker URL if it's Redis
+                broker = self.app.conf.broker_url or ""
+                if broker.startswith("redis://") or broker.startswith("rediss://"):
+                    url = broker
+            if url:
+                self._singleton_backend = RedisLockBackend(url)
+        return self._singleton_backend
+
+    @property
+    def _lock_expiry(self) -> int:
+        if self.lock_expiry is not None:
+            return self.lock_expiry
+        return self.singleton_config.lock_expiry
+
+    @property
+    def _raise_on_duplicate(self) -> bool:
+        if self.raise_on_duplicate is not None:
+            return self.raise_on_duplicate
+        return self.singleton_config.raise_on_duplicate
+
+    def generate_lock(
+        self,
+        task_name: str,
+        task_args: list[Any] | tuple[Any, ...] | None = None,
+        task_kwargs: dict[str, Any] | None = None,
+    ) -> str:
+        """Generate lock key, supporting nested attribute access via unique_on."""
+        unique_on = self.unique_on
+        task_args = task_args or []
+        task_kwargs = task_kwargs or {}
+
+        if unique_on:
+            if isinstance(unique_on, str):
+                unique_on = [unique_on]
+
+            # Bind arguments to function signature
+            sig = inspect.signature(self.run)
+            bound = sig.bind(*task_args, **task_kwargs).arguments
+
+            unique_args: list[Any] = []
+            for key in unique_on:
+                keys = key.split(".")
+                if keys[0] not in bound:
+                    raise ValueError(f"Key '{keys[0]}' not found in task arguments")
+
+                value = bound[keys[0]]
+                # Navigate nested structure (supports one level of nesting)
+                if len(keys) == 2:
+                    nested_key = keys[1]
+                    if isinstance(value, dict):
+                        if nested_key not in value:
+                            raise ValueError(f"Key '{nested_key}' not found in dict")
+                        unique_args.append(value[nested_key])
+                    elif isinstance(value, (list, tuple)):
+                        unique_args.append(value[int(nested_key)])
+                    elif hasattr(value, nested_key):
+                        unique_args.append(getattr(value, nested_key))
+                    else:
+                        raise ValueError(f"Key '{key}' has unsupported type")
+                elif len(keys) == 1:
+                    unique_args.append(value)
+                else:
+                    raise ValueError(f"Key '{key}' has too many levels (max 2)")
+
+            return generate_lock_key(
+                task_name,
+                unique_args,
+                {},
+                key_prefix=self.singleton_config.key_prefix,
+            )
+        else:
+            return generate_lock_key(
+                task_name,
+                list(task_args),
+                task_kwargs,
+                key_prefix=self.singleton_config.key_prefix,
+            )
+
+    def acquire_lock(self, lock_key: str, task_id: str) -> bool:
+        """Attempt to acquire lock. Returns True if successful."""
+        backend = self.singleton_backend
+        if backend is None:
+            return True  # No Redis = no locking
+        return backend.lock(lock_key, task_id, expiry=self._lock_expiry)
+
+    def release_lock(
+        self,
+        task_args: list[Any] | tuple[Any, ...] | None = None,
+        task_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        """Release the lock for this task."""
+        backend = self.singleton_backend
+        if backend is None:
+            return
+        lock_key = self.generate_lock(self.name, task_args, task_kwargs)
+        backend.unlock(lock_key)
+
+    def get_existing_task_id(self, lock_key: str) -> str | None:
+        """Get task ID holding the lock, if any."""
+        backend = self.singleton_backend
+        if backend is None:
+            return None
+        return backend.get(lock_key)
+
+    def apply_async(
+        self,
+        args: list[Any] | tuple[Any, ...] | None = None,
+        kwargs: dict[str, Any] | None = None,
+        task_id: str | None = None,
+        **options: Any,
+    ) -> Any:
+        """Override apply_async to implement singleton behavior."""
+        args = args or []
+        kwargs = kwargs or {}
+        task_id = task_id or str(uuid4())
+
+        backend = self.singleton_backend
+        if backend is None:
+            # No Redis = normal behavior
+            return super().apply_async(args, kwargs, task_id=task_id, **options)
+
+        lock_key = self.generate_lock(self.name, args, kwargs)
+
+        # Try to acquire lock and run
+        if self.acquire_lock(lock_key, task_id):
+            try:
+                return super().apply_async(args, kwargs, task_id=task_id, **options)
+            except Exception:
+                # Release lock if apply_async fails
+                backend.unlock(lock_key)
+                raise
+
+        # Lock not acquired - check for existing task
+        existing_task_id = self.get_existing_task_id(lock_key)
+        if existing_task_id:
+            logger.debug(
+                "Singleton: duplicate task blocked",
+                task=self.name,
+                existing_task_id=existing_task_id,
+            )
+            if self._raise_on_duplicate:
+                raise DuplicateTaskError(f"Duplicate of task {existing_task_id}", existing_task_id)
+            return self.AsyncResult(existing_task_id)
+
+        # Race condition: lock disappeared, retry
+        if self.acquire_lock(lock_key, task_id):
+            try:
+                return super().apply_async(args, kwargs, task_id=task_id, **options)
+            except Exception:
+                backend.unlock(lock_key)
+                raise
+
+        # Still can't acquire - return existing or submit anyway
+        existing_task_id = self.get_existing_task_id(lock_key)
+        if existing_task_id:
+            return self.AsyncResult(existing_task_id)
+
+        # Fallback: submit anyway (rare edge case)
+        logger.warning(f"Singleton lock unstable, submitting anyway: {self.name}")
+        return super().apply_async(args, kwargs, task_id=task_id, **options)
+
+    def on_success(
+        self, retval: Any, task_id: str, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> None:
+        """Release lock on successful task completion."""
+        if self.release_lock_on_success:
+            self.release_lock(task_args=args, task_kwargs=kwargs)
+
+    def on_failure(
+        self,
+        exc: Exception,
+        task_id: str,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        einfo: Any,
+    ) -> None:
+        """
+        Retry-aware lock management on failure.
+
+        - If task will retry: Keep lock
+        - If max retries exceeded: Release lock
+        """
+        max_retries_exceeded = False
+        if hasattr(self, "request") and self.request:
+            current_retries = getattr(self.request, "retries", 0)
+            max_retries = self.max_retries if self.max_retries is not None else 3
+            max_retries_exceeded = current_retries >= max_retries
+
+        if self.release_lock_on_failure or max_retries_exceeded:
+            self.release_lock(task_args=args, task_kwargs=kwargs)
+            if max_retries_exceeded:
+                logger.warning(
+                    f"Task {self.name} failed after {current_retries} retries. Lock released.",
+                    task_id=task_id,
+                    error=str(exc),
+                )
+
+        # Log appropriately
+        if isinstance(exc, WorkerLostError):
+            logger.warning("Task interrupted due to worker loss", task_id=task_id)
+        else:
+            logger.error(
+                f"Task {self.name} failed: {exc}",
+                task_id=task_id,
+                traceback=einfo.traceback if einfo else None,
+            )
+
+    def on_retry(
+        self,
+        exc: Exception,
+        task_id: str,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        einfo: Any,
+    ) -> None:
+        """Lock is retained during retry."""
+        logger.warning(
+            f"Task {self.name} retrying (lock retained)",
+            task_id=task_id,
+            retry_count=self.request.retries,
+        )

pyworkflow/celery/tasks.py

@@ -19,12 +19,12 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from pyworkflow.context.step_context import StepContext
 
-from celery import Task
-from celery.exceptions import MaxRetriesExceededError, Retry, WorkerLostError
+from celery.exceptions import MaxRetriesExceededError, Retry
 from loguru import logger
 
 from pyworkflow.celery.app import celery_app
 from pyworkflow.celery.loop import run_async
+from pyworkflow.celery.singleton import SingletonWorkflowTask
 from pyworkflow.core.exceptions import (
     CancellationError,
     ContinueAsNewSignal,
@@ -33,6 +33,7 @@ from pyworkflow.core.exceptions import (
     SuspensionSignal,
 )
 from pyworkflow.core.registry import WorkflowMetadata, get_workflow
+from pyworkflow.core.validation import validate_step_parameters
 from pyworkflow.core.workflow import execute_workflow_with_context
 from pyworkflow.engine.events import (
     EventType,
@@ -73,58 +74,15 @@ def _calculate_exponential_backoff(
     return delay * jitter
 
 
-class WorkflowTask(Task):
-    """Base task class for workflow execution with custom error handling."""
-
-    # Allow unlimited Celery-level retries - our code controls the actual limit
-    # via the max_retries parameter passed to execute_step_task
-    max_retries = None
-    # Prevent message requeue loops when task fails
-    acks_on_failure_or_timeout = True
-
-    def on_failure(self, exc, task_id, args, kwargs, einfo):
-        """
-        Handle task failure.
-
-        Detects worker loss and handles recovery appropriately:
-        - WorkerLostError: Infrastructure failure, may trigger recovery
-        - Other exceptions: Application failure
-        """
-        is_worker_loss = isinstance(exc, WorkerLostError)
-        if is_worker_loss:
-            logger.warning(
-                f"Task {self.name} interrupted due to worker loss",
-                task_id=task_id,
-                error=str(exc),
-            )
-            # Note: Recovery is handled when the task is requeued and picked up
-            # by another worker. See _handle_workflow_recovery() for logic.
-        else:
-            logger.error(
-                f"Task {self.name} failed: {str(exc)}",
-                task_id=task_id,
-                error=str(exc),
-                traceback=einfo.traceback if einfo else None,
-            )
-
-    def on_retry(self, exc, task_id, args, kwargs, einfo):
-        """Handle task retry."""
-        logger.warning(
-            f"Task {self.name} retrying",
-            task_id=task_id,
-            error=str(exc),
-            retry_count=self.request.retries,
-        )
-
-
 @celery_app.task(
     name="pyworkflow.execute_step",
-    base=WorkflowTask,
+    base=SingletonWorkflowTask,
     bind=True,
     queue="pyworkflow.steps",
+    unique_on=["run_id", "step_id"],
 )
 def execute_step_task(
-    self: WorkflowTask,
+    self: SingletonWorkflowTask,
     step_name: str,
     args_json: str,
     kwargs_json: str,
@@ -212,10 +170,28 @@ def execute_step_task(
         )
         raise FatalError(f"Step '{step_name}' not found in registry")
 
+    # Ignore processing step if already completed (idempotency)
+    events = run_async(storage.get_events(run_id))
+    already_completed = any(
+        evt.type == EventType.STEP_COMPLETED and evt.data.get("step_id") == step_id
+        for evt in events
+    )
+    if already_completed:
+        logger.warning(
+            "Step already completed by another task, skipping execution",
+            run_id=run_id,
+            step_id=step_id,
+            step_name=step_name,
+        )
+        return None
+
     # Deserialize arguments
     args = deserialize_args(args_json)
     kwargs = deserialize_kwargs(kwargs_json)
 
+    # Validate parameters before execution on worker (defense in depth)
+    validate_step_parameters(step_meta.original_func, args, kwargs, step_name)
+
     # Set up step context if provided (read-only mode)
     step_context_token = None
     readonly_token = None
@@ -608,8 +584,9 @@ def _resolve_context_class(class_name: str) -> type["StepContext"] | None:
 
 @celery_app.task(
     name="pyworkflow.start_workflow",
-    base=WorkflowTask,
+    base=SingletonWorkflowTask,
     queue="pyworkflow.workflows",
+    unique_on=["run_id"],
 )
 def start_workflow_task(
     workflow_name: str,
@@ -678,8 +655,9 @@ def start_workflow_task(
 
 @celery_app.task(
     name="pyworkflow.start_child_workflow",
-    base=WorkflowTask,
+    base=SingletonWorkflowTask,
     queue="pyworkflow.workflows",
+    unique_on=["child_run_id"],
 )
 def start_child_workflow_task(
     workflow_name: str,
@@ -1719,8 +1697,9 @@ async def _start_workflow_on_worker(
 
 @celery_app.task(
     name="pyworkflow.resume_workflow",
-    base=WorkflowTask,
+    base=SingletonWorkflowTask,
     queue="pyworkflow.schedules",
+    unique_on=["run_id"],
 )
 def resume_workflow_task(
     run_id: str,
@@ -1766,8 +1745,9 @@ def resume_workflow_task(
 
 @celery_app.task(
     name="pyworkflow.execute_scheduled_workflow",
-    base=WorkflowTask,
+    base=SingletonWorkflowTask,
     queue="pyworkflow.schedules",
+    # No unique_on - scheduled workflows create new runs each time, no deduplication needed
 )
 def execute_scheduled_workflow_task(
     schedule_id: str,

pyworkflow/core/step.py

@@ -23,6 +23,7 @@ from loguru import logger
 from pyworkflow.context import get_context, has_context
 from pyworkflow.core.exceptions import FatalError, RetryableError
 from pyworkflow.core.registry import register_step
+from pyworkflow.core.validation import validate_step_parameters
 from pyworkflow.engine.events import (
     create_step_completed_event,
     create_step_failed_event,
@@ -118,6 +119,8 @@ def step(
                     f"Step {step_name} in transient mode, executing directly",
                     run_id=ctx.run_id,
                 )
+                # Validate parameters before execution
+                validate_step_parameters(func, args, kwargs, step_name)
                 return await _execute_with_retries(
                     func, args, kwargs, step_name, max_retries, retry_delay
                 )
@@ -172,6 +175,8 @@ def step(
             # When running in a distributed runtime (e.g., Celery), dispatch steps
             # to step workers instead of executing inline.
             if ctx.runtime == "celery":
+                # Validate parameters before dispatching to Celery
+                validate_step_parameters(func, args, kwargs, step_name)
                 return await _dispatch_step_to_celery(
                     ctx=ctx,
                     func=func,
@@ -240,6 +245,9 @@ def step(
             # Check for cancellation before executing step
             ctx.check_cancellation()
 
+            # Validate parameters before execution
+            validate_step_parameters(func, args, kwargs, step_name)
+
             try:
                 # Execute step function
                 result = await func(*args, **kwargs)

pyworkflow/core/validation.py

@@ -0,0 +1,112 @@
+"""
+Pydantic validation for step parameters.
+
+Validates step function arguments against their type hints using Pydantic's
+TypeAdapter for runtime type checking.
+"""
+
+import inspect
+from collections.abc import Callable
+from typing import Any, get_type_hints
+
+from pydantic import TypeAdapter, ValidationError
+
+from pyworkflow.core.exceptions import FatalError
+
+
+class StepValidationError(FatalError):
+    """
+    Raised when step parameter validation fails.
+
+    This is a FatalError subclass to ensure validation failures
+    immediately fail the workflow without retries.
+    """
+
+    def __init__(
+        self,
+        step_name: str,
+        param_name: str,
+        expected_type: type,
+        received_value: Any,
+        validation_error: ValidationError,
+    ) -> None:
+        self.step_name = step_name
+        self.param_name = param_name
+        self.expected_type = expected_type
+        self.received_value = received_value
+        self.validation_error = validation_error
+
+        # Build clear error message
+        error_details = str(validation_error)
+        message = (
+            f"Step '{step_name}' parameter validation failed for '{param_name}': "
+            f"expected {expected_type}, got {type(received_value).__name__} "
+            f"with value {received_value!r}. Details: {error_details}"
+        )
+        super().__init__(message)
+
+
+def validate_step_parameters(
+    func: Callable,
+    args: tuple,
+    kwargs: dict,
+    step_name: str,
+) -> None:
+    """
+    Validate step parameters against their type hints using Pydantic.
+
+    Only parameters with type annotations are validated. Parameters without
+    type hints are skipped.
+
+    Args:
+        func: The step function (original, unwrapped)
+        args: Positional arguments passed to the step
+        kwargs: Keyword arguments passed to the step
+        step_name: Name of the step for error messages
+
+    Raises:
+        StepValidationError: If any typed parameter fails validation
+    """
+    # Get function signature and type hints
+    sig = inspect.signature(func)
+
+    try:
+        # Try to get type hints, may fail for some edge cases
+        type_hints = get_type_hints(func)
+    except Exception:
+        # If we can't get type hints, skip validation
+        return
+
+    if not type_hints:
+        # No type hints at all, skip validation
+        return
+
+    # Bind arguments to parameters
+    try:
+        bound = sig.bind(*args, **kwargs)
+        bound.apply_defaults()
+    except TypeError:
+        # If binding fails, the function call itself will fail
+        # Let the normal execution handle this
+        return
+
+    # Validate each parameter that has a type hint
+    for param_name, param_value in bound.arguments.items():
+        if param_name not in type_hints:
+            # No type hint for this parameter, skip validation
+            continue
+
+        expected_type = type_hints[param_name]
+
+        try:
+            # Use Pydantic TypeAdapter for validation
+            adapter = TypeAdapter(expected_type)
+            adapter.validate_python(param_value)
+        except ValidationError as e:
+            raise StepValidationError(
+                step_name=step_name,
+                param_name=param_name,
+                expected_type=expected_type,
+                received_value=param_value,
+                validation_error=e,
+            )

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

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

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

@@ -1,4 +1,4 @@
-pyworkflow/__init__.py,sha256=q49wycfPtEoYrdpy3Ic-ox-k1f_zUw1NaOjUvO3EuRU,6281
+pyworkflow/__init__.py,sha256=C7t5zLS32QNzI2BXNdGpWXwzgNyUVchs6L7dcx0p84c,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
@@ -6,10 +6,11 @@ pyworkflow/aws/context.py,sha256=Vjyjip6U1Emg-WA5TlBaxFhcg15rf9mVJiPfT4VywHc,821
 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
-pyworkflow/celery/app.py,sha256=sIbnz40KGIvPC84f7X-Ds7_GvFhzOZOciSeslk57Cig,9223
+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/tasks.py,sha256=gPdZZ0YOpqPVcj4fNgwVreSKf8gAGaw6v2yGZyYrUvA,82663
+pyworkflow/celery/singleton.py,sha256=BykAovBVP0XUo2ZbTQzD4fANa6C_lHSqqaWnhfNfQGw,12978
+pyworkflow/celery/tasks.py,sha256=uHpOoHvZd72CYxCG4yhjgyT7j12fOoyf2380pJgMACs,82083
 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
@@ -42,7 +43,8 @@ pyworkflow/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyworkflow/core/exceptions.py,sha256=F2nbXyoed7wlIJMeGfpgsIC8ZyWcYN0iKtOnBA7-xnQ,10719
 pyworkflow/core/registry.py,sha256=ZUf2YTpBvWpC9EehRbMF8soXOk9VsjNruoi6lR4O33M,9361
 pyworkflow/core/scheduled.py,sha256=479A7IvjHiMob7ZrZtfE6VqtypG6DLIGMGhh16jLIWM,10522
-pyworkflow/core/step.py,sha256=8S_O_KVoaCJSkE5oUslj8orR-S4qSR6_vQoE0NtZ4dU,23463
+pyworkflow/core/step.py,sha256=9JG9udEDph_6ecfruVdY0qC3ruoC6bjd0F91chg8QZM,23913
+pyworkflow/core/validation.py,sha256=0VaZyQ9YGK8WFy4ZG4Bjt9MYAp0vz6xEOe80kcgaP5g,3362
 pyworkflow/core/workflow.py,sha256=dlcICq1B69-nxUJth_n-H8U9TjP3QZyjvquQXxWHcxs,12076
 pyworkflow/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyworkflow/engine/events.py,sha256=KFtyIqQjr1B9Frtd5V1Zq0ph1iwg_Ky3uPzmTYZ1Tnk,25827
@@ -84,9 +86,9 @@ pyworkflow/storage/sqlite.py,sha256=oBzJnnOp2uk0-U7hMTQk9QgJq3RBwXPQfrmYpivjdgE,
 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.12.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
-pyworkflow_engine-0.1.12.dist-info/METADATA,sha256=lzNct37FWxwhEN07OT37QwSFOiQ2YPSjo5TxonKN1sY,19628
-pyworkflow_engine-0.1.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyworkflow_engine-0.1.12.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
-pyworkflow_engine-0.1.12.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
-pyworkflow_engine-0.1.12.dist-info/RECORD,,
+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,,