pyworkflow-engine 0.2.1__tar.gz → 0.2.3__tar.gz

{pyworkflow_engine-0.2.1 → pyworkflow_engine-0.2.3}/PKG-INFO

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

{pyworkflow_engine-0.2.1 → pyworkflow_engine-0.2.3}/pyproject.toml

@@ -7,7 +7,7 @@ packages = [{include = "pyworkflow"}]
 
 [project]
 name = "pyworkflow-engine"
-version = "0.2.1"
+version = "0.2.3"
 description = "A Python implementation of durable, event-sourced workflows inspired by Vercel Workflow"
 readme = "README.md"
 requires-python = ">=3.11"

{pyworkflow_engine-0.2.1 → pyworkflow_engine-0.2.3}/pyworkflow/__init__.py

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

{pyworkflow_engine-0.2.1 → pyworkflow_engine-0.2.3}/pyworkflow/celery/app.py

@@ -304,33 +304,17 @@ def create_celery_app(
         # Broker transport options - prevent task redelivery
         # See: https://github.com/celery/celery/issues/5935
         "broker_transport_options": final_broker_opts,
-        # Task routing
+        # Task routing — use direct exchange (each task specifies queue= explicitly)
         "task_default_queue": "pyworkflow.default",
         "task_default_exchange": "pyworkflow",
-        "task_default_exchange_type": "topic",
-        "task_default_routing_key": "workflow.default",
+        "task_default_exchange_type": "direct",
+        "task_default_routing_key": "pyworkflow.default",
         # Task queues
         "task_queues": (
-            Queue(
-                "pyworkflow.default",
-                Exchange("pyworkflow", type="topic"),
-                routing_key="workflow.#",
-            ),
-            Queue(
-                "pyworkflow.steps",
-                Exchange("pyworkflow", type="topic"),
-                routing_key="workflow.step.#",
-            ),
-            Queue(
-                "pyworkflow.workflows",
-                Exchange("pyworkflow", type="topic"),
-                routing_key="workflow.workflow.#",
-            ),
-            Queue(
-                "pyworkflow.schedules",
-                Exchange("pyworkflow", type="topic"),
-                routing_key="workflow.schedule.#",
-            ),
+            Queue("pyworkflow.default", Exchange("pyworkflow", type="direct")),
+            Queue("pyworkflow.steps", Exchange("pyworkflow", type="direct")),
+            Queue("pyworkflow.workflows", Exchange("pyworkflow", type="direct")),
+            Queue("pyworkflow.schedules", Exchange("pyworkflow", type="direct")),
         ),
         # Task execution
         "task_acks_late": True,

{pyworkflow_engine-0.2.1 → pyworkflow_engine-0.2.3}/pyworkflow/celery/tasks.py

@@ -10,7 +10,6 @@ These tasks enable:
 """
 
 import asyncio
-import contextlib
 import random
 import uuid
 from collections.abc import Callable
@@ -186,51 +185,6 @@ def execute_step_task(
         )
         return None
 
-    # Execution-time guard: prevent duplicate step execution on concurrent workers.
-    # The singleton lock (unique_on=["run_id", "step_id"]) prevents duplicate queueing,
-    # but broker-level re-delivery or race conditions can still result in two workers
-    # executing the same step. This Redis lock ensures only one proceeds.
-    _exec_lock_key = f"pyworkflow:step_exec:{run_id}:{step_id}"
-    _exec_lock_backend = self.singleton_backend
-    _exec_lock_acquired = False
-    if _exec_lock_backend is not None:
-        _exec_lock_acquired = _exec_lock_backend.lock(
-            _exec_lock_key, self.request.id or "unknown", expiry=self._lock_expiry
-        )
-        if not _exec_lock_acquired:
-            # Check for worker-loss re-delivery: when a worker dies mid-step
-            # (e.g., spot instance termination), Celery re-delivers the same
-            # message with the same task_id (task_reject_on_worker_lost=True).
-            # The dead worker's lock still exists in Redis (up to 1h TTL).
-            # If the lock holder matches our own task_id, this IS a re-delivery
-            # of the same task — force-acquire and proceed.
-            _holding_task_id = _exec_lock_backend.get(_exec_lock_key)
-            _our_task_id = self.request.id or "unknown"
-            if _holding_task_id == _our_task_id:
-                logger.warning(
-                    "Step lock held by same task_id — worker-loss re-delivery detected, "
-                    "force-acquiring lock",
-                    run_id=run_id,
-                    step_id=step_id,
-                    step_name=step_name,
-                    task_id=_our_task_id,
-                )
-                _exec_lock_backend.unlock(_exec_lock_key)
-                _exec_lock_acquired = _exec_lock_backend.lock(
-                    _exec_lock_key, _our_task_id, expiry=self._lock_expiry
-                )
-            else:
-                logger.warning(
-                    "Step already being executed by another worker, skipping duplicate",
-                    run_id=run_id,
-                    step_id=step_id,
-                    step_name=step_name,
-                    existing_worker_task=_holding_task_id,
-                )
-                return None
-    else:
-        _exec_lock_acquired = True  # No Redis = no locking
-
     # Deserialize arguments
     args = deserialize_args(args_json)
     kwargs = deserialize_kwargs(kwargs_json)
@@ -497,11 +451,6 @@ def execute_step_task(
             raise FatalError(f"Step '{step_name}' failed after retries: {str(e)}") from e
 
     finally:
-        # Release execution lock so retries or other tasks can proceed.
-        if _exec_lock_acquired and _exec_lock_backend is not None:
-            with contextlib.suppress(Exception):
-                _exec_lock_backend.unlock(_exec_lock_key)
-
         # Clean up step execution context (checkpoint/hook primitives)
         if step_exec_tokens is not None:
             from pyworkflow.primitives.step_checkpoint import reset_step_execution_context
@@ -886,83 +835,33 @@ def start_workflow_task(
         celery_task_id=self.request.id,
     )
 
-    # Execution-time guard: prevent duplicate workflow start on concurrent workers.
-    # The singleton lock (unique_on=["run_id"]) prevents duplicate queueing, but
-    # broker-level re-delivery or race conditions can still result in two workers
-    # executing the same start task. This Redis lock ensures only one proceeds.
-    _exec_lock_key = f"pyworkflow:wf_start:{run_id}"
-    _exec_lock_backend = self.singleton_backend
-    _exec_lock_acquired = False
-    _is_redelivery = False
-    if _exec_lock_backend is not None:
-        _exec_lock_acquired = _exec_lock_backend.lock(
-            _exec_lock_key, self.request.id or "unknown", expiry=self._lock_expiry
-        )
-        if not _exec_lock_acquired:
-            # Check for worker-loss re-delivery (same logic as step tasks):
-            # if the lock holder matches our task_id, this is the same message
-            # re-delivered after the original worker died.
-            _holding_task_id = _exec_lock_backend.get(_exec_lock_key)
-            _our_task_id = self.request.id or "unknown"
-            if _holding_task_id == _our_task_id:
-                logger.warning(
-                    "Workflow start lock held by same task_id — worker-loss re-delivery "
-                    "detected, force-acquiring lock",
-                    run_id=run_id,
-                    workflow_name=workflow_name,
-                    task_id=_our_task_id,
-                )
-                _exec_lock_backend.unlock(_exec_lock_key)
-                _exec_lock_acquired = _exec_lock_backend.lock(
-                    _exec_lock_key, _our_task_id, expiry=self._lock_expiry
-                )
-                _is_redelivery = True
-            else:
-                logger.warning(
-                    "Workflow start already being executed by another worker, skipping duplicate",
-                    run_id=run_id,
-                    workflow_name=workflow_name,
-                    existing_worker_task=_holding_task_id,
-                )
-                return run_id
-    else:
-        _exec_lock_acquired = True  # No Redis = no locking
-
-    try:
-        # Get workflow metadata
-        workflow_meta = get_workflow(workflow_name)
-        if not workflow_meta:
-            raise ValueError(f"Workflow '{workflow_name}' not found in registry")
+    # Get workflow metadata
+    workflow_meta = get_workflow(workflow_name)
+    if not workflow_meta:
+        raise ValueError(f"Workflow '{workflow_name}' not found in registry")
 
-        # Deserialize arguments
-        args = deserialize_args(args_json)
-        kwargs = deserialize_kwargs(kwargs_json)
+    # Deserialize arguments
+    args = deserialize_args(args_json)
+    kwargs = deserialize_kwargs(kwargs_json)
 
-        # Get storage backend
-        storage = _get_storage_backend(storage_config)
+    # Get storage backend
+    storage = _get_storage_backend(storage_config)
 
-        # Execute workflow directly on worker
-        result_run_id = run_async(
-            _start_workflow_on_worker(
-                workflow_meta=workflow_meta,
-                args=args,
-                kwargs=kwargs,
-                storage=storage,
-                storage_config=storage_config,
-                idempotency_key=idempotency_key,
-                run_id=run_id,
-                is_redelivery=_is_redelivery,
-            )
+    # Execute workflow directly on worker
+    result_run_id = run_async(
+        _start_workflow_on_worker(
+            workflow_meta=workflow_meta,
+            args=args,
+            kwargs=kwargs,
+            storage=storage,
+            storage_config=storage_config,
+            idempotency_key=idempotency_key,
+            run_id=run_id,
         )
+    )
 
-        logger.info(f"Workflow execution initiated: {workflow_name}", run_id=result_run_id)
-        return result_run_id
-
-    finally:
-        # Release execution lock so retries or re-dispatches can proceed.
-        if _exec_lock_acquired and _exec_lock_backend is not None:
-            with contextlib.suppress(Exception):
-                _exec_lock_backend.unlock(_exec_lock_key)
+    logger.info(f"Workflow execution initiated: {workflow_name}", run_id=result_run_id)
+    return result_run_id
 
 
 @celery_app.task(
@@ -1631,7 +1530,6 @@ async def _start_workflow_on_worker(
     storage_config: dict[str, Any] | None = None,
     idempotency_key: str | None = None,
     run_id: str | None = None,
-    is_redelivery: bool = False,
 ) -> str:
     """
     Internal function to start workflow on Celery worker.
@@ -1647,10 +1545,6 @@ async def _start_workflow_on_worker(
         storage_config: Storage configuration for child tasks
         idempotency_key: Optional idempotency key
         run_id: Pre-generated run ID (if None, generates a new one)
-        is_redelivery: True when Celery re-delivered the same task_id after
-            worker loss. Re-deliveries bypass the recovery_attempts counter
-            since they represent the same logical execution, not an additional
-            recovery attempt.
     """
     from pyworkflow.config import get_config
 
@@ -1691,24 +1585,6 @@ async def _start_workflow_on_worker(
                     )
                     return existing_run.run_id
 
-                if is_redelivery:
-                    # Celery re-delivered the same task after worker loss.
-                    # This is NOT an extra recovery attempt — it is the same
-                    # logical execution being retried by the broker.  Skip the
-                    # recovery-attempts counter and go straight to replay.
-                    logger.info(
-                        "Worker-loss re-delivery: recovering without counting "
-                        "against max_recovery_attempts",
-                        run_id=existing_run.run_id,
-                        workflow_name=existing_run.workflow_name,
-                    )
-                    return await _recover_workflow_on_worker(
-                        run=existing_run,
-                        workflow_meta=workflow_meta,
-                        storage=storage,
-                        storage_config=storage_config,
-                    )
-
                 # This is a recovery scenario - worker crashed while running
                 can_recover = await _handle_workflow_recovery(
                     run=existing_run,
@@ -1765,22 +1641,6 @@ async def _start_workflow_on_worker(
         )
 
         if existing_run.status == RunStatus.RUNNING:
-            if is_redelivery:
-                # Celery re-delivered the same task after worker loss.
-                # Skip recovery-attempts counter — same logical execution.
-                logger.info(
-                    "Worker-loss re-delivery: recovering without counting "
-                    "against max_recovery_attempts",
-                    run_id=run_id,
-                    workflow_name=existing_run.workflow_name,
-                )
-                return await _recover_workflow_on_worker(
-                    run=existing_run,
-                    workflow_meta=workflow_meta,
-                    storage=storage,
-                    storage_config=storage_config,
-                )
-
             # Recovery scenario - worker crashed while running
             can_recover = await _handle_workflow_recovery(
                 run=existing_run,

{pyworkflow_engine-0.2.1 → pyworkflow_engine-0.2.3}/pyworkflow/core/step.py

@@ -669,7 +669,8 @@ async def _dispatch_step_to_celery(
 
     # 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.
+    # replay past the same step. If already started, re-suspend to wait for
+    # the running task to complete via task_reject_on_worker_lost re-delivery.
     # Exception: if STEP_SUSPENDED was recorded (step_hook suspension), the step
     # needs re-dispatch so it can re-execute and find the HOOK_RECEIVED event.
     events = await ctx.storage.get_events(ctx.run_id)
@@ -682,7 +683,7 @@ async def _dispatch_step_to_celery(
     )
     if already_started and not was_suspended:
         logger.info(
-            f"Step {step_name} already has STEP_STARTED event, re-suspending",
+            f"Step {step_name} already has STEP_STARTED event, re-suspending (task running)",
             run_id=ctx.run_id,
             step_id=step_id,
         )