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

pyworkflow/storage/config.py

@@ -5,12 +5,42 @@ This module provides functions to serialize storage backends to configuration
 dicts and recreate storage backends from configuration dicts. This is used
 for passing storage configuration to Celery tasks and other cross-process
 communication.
+
+Storage backends are cached per-process to reuse connection pools and avoid
+connection exhaustion (e.g., "too many clients" errors with PostgreSQL).
+
+Note: For async backends (postgres, mysql), the backends handle event loop
+changes internally by detecting loop mismatches and recreating the pool.
 """
 
+import contextlib
+import hashlib
+import json
 from typing import Any
 
 from pyworkflow.storage.base import StorageBackend
 
+# Module-level cache for storage backends (per-worker singleton pattern)
+# Key: hash of config dict, Value: tuple of (StorageBackend, reserved for future use)
+_storage_cache: dict[str, tuple[StorageBackend, None]] = {}
+
+
+def _config_to_cache_key(config: dict[str, Any] | None) -> str:
+    """
+    Create a cache key from config dict.
+
+    Args:
+        config: Configuration dict
+
+    Returns:
+        Cache key string (MD5 hash of serialized config)
+    """
+    if config is None:
+        return "default"
+    # Sort keys for consistent hashing
+    serialized = json.dumps(config, sort_keys=True)
+    return hashlib.md5(serialized.encode()).hexdigest()
+
 
 def storage_to_config(storage: StorageBackend | None) -> dict[str, Any] | None:
     """
@@ -106,14 +136,20 @@ def storage_to_config(storage: StorageBackend | None) -> dict[str, Any] | None:
 
 def config_to_storage(config: dict[str, Any] | None = None) -> StorageBackend:
     """
-    Create storage backend from configuration dict.
+    Create or return cached storage backend from configuration dict.
+
+    Storage backends are cached per-process to reuse connection pools.
+    This prevents connection exhaustion with pooled backends like PostgreSQL.
+
+    For async backends (postgres, mysql), the backend handles event loop
+    changes internally by detecting loop mismatches and recreating the pool.
 
     Args:
         config: Configuration dict with 'type' and backend-specific params.
                 If None, returns default FileStorageBackend.
 
     Returns:
-        Storage backend instance
+        Storage backend instance (may be cached)
 
     Raises:
         ValueError: If storage type is unknown
@@ -124,6 +160,25 @@ def config_to_storage(config: dict[str, Any] | None = None) -> StorageBackend:
         >>> isinstance(storage, FileStorageBackend)
         True
     """
+    cache_key = _config_to_cache_key(config)
+
+    if cache_key in _storage_cache:
+        cached_storage, _ = _storage_cache[cache_key]
+        return cached_storage
+
+    # Create new instance
+    storage = _create_storage_backend(config)
+    _storage_cache[cache_key] = (storage, None)
+    return storage
+
+
+def _create_storage_backend(config: dict[str, Any] | None) -> StorageBackend:
+    """
+    Internal function that creates a new storage backend instance.
+
+    This should not be called directly - use config_to_storage() instead
+    to benefit from caching.
+    """
     if not config:
         from pyworkflow.storage.file import FileStorageBackend
 
@@ -252,3 +307,27 @@ def config_to_storage(config: dict[str, Any] | None = None) -> StorageBackend:
 
     else:
         raise ValueError(f"Unknown storage type: {storage_type}")
+
+
+async def disconnect_all_cached() -> None:
+    """
+    Disconnect all cached storage backends.
+
+    Call this on worker shutdown to properly close connection pools.
+    This is automatically called by the Celery worker_shutdown signal handler.
+    """
+    for storage, _ in _storage_cache.values():
+        if hasattr(storage, "disconnect"):
+            with contextlib.suppress(Exception):
+                await storage.disconnect()
+    _storage_cache.clear()
+
+
+def clear_storage_cache() -> None:
+    """
+    Clear the storage cache without disconnecting.
+
+    Primarily used for testing to ensure fresh instances.
+    For production cleanup, use disconnect_all_cached() instead.
+    """
+    _storage_cache.clear()

pyworkflow/storage/postgres.py

@@ -7,8 +7,14 @@ This backend stores workflow data in a PostgreSQL database, suitable for:
 - High-availability requirements
 
 Provides ACID guarantees, connection pooling, and efficient querying with SQL indexes.
+
+Note: The connection pool is bound to a specific event loop. When running in
+environments where each task creates a new event loop (e.g., Celery prefork),
+the pool is automatically recreated when a loop change is detected.
 """
 
+import asyncio
+import contextlib
 import json
 from datetime import UTC, datetime
 from typing import Any
@@ -72,6 +78,7 @@ class PostgresStorageBackend(StorageBackend):
         self.min_pool_size = min_pool_size
         self.max_pool_size = max_pool_size
         self._pool: asyncpg.Pool | None = None
+        self._pool_loop_id: int | None = None  # Track which loop the pool was created on
         self._initialized = False
 
     def _build_dsn(self) -> str:
@@ -83,13 +90,29 @@ class PostgresStorageBackend(StorageBackend):
         return f"postgresql://{self.user}@{self.host}:{self.port}/{self.database}"
 
     async def connect(self) -> None:
-        """Initialize connection pool and create tables if needed."""
+        """Initialize connection pool and create tables if needed.
+
+        The pool is bound to the current event loop. If the loop has changed
+        since the pool was created (e.g., in Celery prefork workers), the old
+        pool is closed and a new one is created.
+        """
+        current_loop_id = id(asyncio.get_running_loop())
+
+        # Check if we need to recreate the pool due to loop change
+        if self._pool is not None and self._pool_loop_id != current_loop_id:
+            # Loop changed - the old pool is invalid, close it
+            with contextlib.suppress(Exception):
+                self._pool.terminate()  # Use terminate() instead of close() to avoid awaiting on wrong loop
+            self._pool = None
+            self._initialized = False
+
         if self._pool is None:
             self._pool = await asyncpg.create_pool(
                 dsn=self.dsn or self._build_dsn(),
                 min_size=self.min_pool_size,
                 max_size=self.max_pool_size,
             )
+            self._pool_loop_id = current_loop_id
 
         if not self._initialized:
             await self._initialize_schema()
@@ -100,6 +123,7 @@ class PostgresStorageBackend(StorageBackend):
         if self._pool:
             await self._pool.close()
             self._pool = None
+            self._pool_loop_id = None
             self._initialized = False
 
     async def _initialize_schema(self) -> None:
@@ -107,7 +131,7 @@ class PostgresStorageBackend(StorageBackend):
         if not self._pool:
             await self.connect()
 
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
         async with pool.acquire() as conn:
             # Workflow runs table
             await conn.execute("""
@@ -254,17 +278,62 @@ class PostgresStorageBackend(StorageBackend):
                 )
             """)
 
+    async def _get_pool(self) -> asyncpg.Pool:
+        """Get the connection pool, connecting/reconnecting if needed.
+
+        This method ensures the pool is connected and on the correct event loop.
+        It handles automatic reconnection when the event loop has changed.
+        """
+        current_loop_id = id(asyncio.get_running_loop())
+
+        # Check if we need to connect or reconnect
+        # - If no pool exists, we need to connect
+        # - If pool exists but was created on a different loop, we need to reconnect
+        # - If _pool_loop_id is None but pool exists (e.g., mocked for testing),
+        #   we trust the pool and set the loop ID to current
+        if self._pool is None:
+            await self.connect()
+        elif self._pool_loop_id is not None and self._pool_loop_id != current_loop_id:
+            # Pool was created on a different loop - need to reconnect
+            await self.connect()
+        elif self._pool_loop_id is None:
+            # Pool was set externally (e.g., for testing) - track current loop
+            self._pool_loop_id = current_loop_id
+
+        return self._pool  # type: ignore
+
     def _ensure_connected(self) -> asyncpg.Pool:
-        """Ensure database pool is connected."""
+        """Ensure database pool is connected.
+
+        DEPRECATED: Use _get_pool() instead for automatic reconnection.
+        This method is kept for backward compatibility but will raise an error
+        if the pool is on a different event loop.
+        """
         if not self._pool:
             raise RuntimeError("Database not connected. Call connect() first.")
+
+        # Check if we're on a different event loop than when the pool was created
+        try:
+            current_loop_id = id(asyncio.get_running_loop())
+            if self._pool_loop_id is not None and self._pool_loop_id != current_loop_id:
+                raise RuntimeError(
+                    "Database pool was created on a different event loop. "
+                    "Call connect() to recreate the pool on the current loop."
+                )
+        except RuntimeError as e:
+            if "no running event loop" in str(e).lower():
+                # No running loop - this will fail anyway when we try to use the pool
+                pass
+            else:
+                raise
+
         return self._pool
 
     # Workflow Run Operations
 
     async def create_run(self, run: WorkflowRun) -> None:
         """Create a new workflow run record."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute(
@@ -302,7 +371,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def get_run(self, run_id: str) -> WorkflowRun | None:
         """Retrieve a workflow run by ID."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             row = await conn.fetchrow("SELECT * FROM workflow_runs WHERE run_id = $1", run_id)
@@ -314,7 +383,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def get_run_by_idempotency_key(self, key: str) -> WorkflowRun | None:
         """Retrieve a workflow run by idempotency key."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             row = await conn.fetchrow("SELECT * FROM workflow_runs WHERE idempotency_key = $1", key)
@@ -332,7 +401,7 @@ class PostgresStorageBackend(StorageBackend):
         error: str | None = None,
     ) -> None:
         """Update workflow run status."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         now = datetime.now(UTC)
         completed_at = now if status == RunStatus.COMPLETED else None
@@ -371,7 +440,7 @@ class PostgresStorageBackend(StorageBackend):
         recovery_attempts: int,
     ) -> None:
         """Update the recovery attempts counter for a workflow run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute(
@@ -391,7 +460,7 @@ class PostgresStorageBackend(StorageBackend):
         context: dict,
     ) -> None:
         """Update the step context for a workflow run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute(
@@ -420,7 +489,7 @@ class PostgresStorageBackend(StorageBackend):
         cursor: str | None = None,
     ) -> tuple[list[WorkflowRun], str | None]:
         """List workflow runs with optional filtering and pagination."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         conditions = []
         params: list[Any] = []
@@ -482,7 +551,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def record_event(self, event: Event) -> None:
         """Record an event to the append-only event log."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn, conn.transaction():
             # Get next sequence number and insert in a transaction
@@ -511,7 +580,7 @@ class PostgresStorageBackend(StorageBackend):
         event_types: list[str] | None = None,
     ) -> list[Event]:
         """Retrieve all events for a workflow run, ordered by sequence."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             if event_types:
@@ -538,7 +607,7 @@ class PostgresStorageBackend(StorageBackend):
         event_type: str | None = None,
     ) -> Event | None:
         """Get the latest event for a run, optionally filtered by type."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             if event_type:
@@ -572,7 +641,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def create_step(self, step: StepExecution) -> None:
         """Create a step execution record."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute(
@@ -598,7 +667,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def get_step(self, step_id: str) -> StepExecution | None:
         """Retrieve a step execution by ID."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             row = await conn.fetchrow("SELECT * FROM steps WHERE step_id = $1", step_id)
@@ -616,7 +685,7 @@ class PostgresStorageBackend(StorageBackend):
         error: str | None = None,
     ) -> None:
         """Update step execution status."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         updates = ["status = $1"]
         params: list[Any] = [status]
@@ -647,7 +716,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def list_steps(self, run_id: str) -> list[StepExecution]:
         """List all steps for a workflow run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             rows = await conn.fetch(
@@ -661,7 +730,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def create_hook(self, hook: Hook) -> None:
         """Create a hook record."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute(
@@ -684,7 +753,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def get_hook(self, hook_id: str) -> Hook | None:
         """Retrieve a hook by ID."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             row = await conn.fetchrow("SELECT * FROM hooks WHERE hook_id = $1", hook_id)
@@ -696,7 +765,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def get_hook_by_token(self, token: str) -> Hook | None:
         """Retrieve a hook by its token."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             row = await conn.fetchrow("SELECT * FROM hooks WHERE token = $1", token)
@@ -713,7 +782,7 @@ class PostgresStorageBackend(StorageBackend):
         payload: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         updates = ["status = $1"]
         params: list[Any] = [status.value]
@@ -745,7 +814,7 @@ class PostgresStorageBackend(StorageBackend):
         offset: int = 0,
     ) -> list[Hook]:
         """List hooks with optional filtering."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         conditions = []
         params: list[Any] = []
@@ -780,7 +849,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def set_cancellation_flag(self, run_id: str) -> None:
         """Set a cancellation flag for a workflow run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute(
@@ -795,7 +864,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def check_cancellation_flag(self, run_id: str) -> bool:
         """Check if a cancellation flag is set for a workflow run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             row = await conn.fetchrow("SELECT 1 FROM cancellation_flags WHERE run_id = $1", run_id)
@@ -804,7 +873,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def clear_cancellation_flag(self, run_id: str) -> None:
         """Clear the cancellation flag for a workflow run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute("DELETE FROM cancellation_flags WHERE run_id = $1", run_id)
@@ -817,7 +886,7 @@ class PostgresStorageBackend(StorageBackend):
         continued_to_run_id: str,
     ) -> None:
         """Update the continuation link for a workflow run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             await conn.execute(
@@ -836,7 +905,7 @@ class PostgresStorageBackend(StorageBackend):
         run_id: str,
     ) -> list[WorkflowRun]:
         """Get all runs in a continue-as-new chain."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         # Find the first run in the chain
         current_id: str | None = run_id
@@ -871,7 +940,7 @@ class PostgresStorageBackend(StorageBackend):
         status: RunStatus | None = None,
     ) -> list[WorkflowRun]:
         """Get all child workflow runs for a parent workflow."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             if status:
@@ -913,7 +982,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def create_schedule(self, schedule: Schedule) -> None:
         """Create a new schedule record."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         # Derive spec_type from the ScheduleSpec
         spec_type = (
@@ -951,7 +1020,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def get_schedule(self, schedule_id: str) -> Schedule | None:
         """Retrieve a schedule by ID."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             row = await conn.fetchrow("SELECT * FROM schedules WHERE schedule_id = $1", schedule_id)
@@ -963,7 +1032,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def update_schedule(self, schedule: Schedule) -> None:
         """Update an existing schedule."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         # Derive spec_type from the ScheduleSpec
         spec_type = (
@@ -1000,7 +1069,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def delete_schedule(self, schedule_id: str) -> None:
         """Mark a schedule as deleted (soft delete)."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         now = datetime.now(UTC)
         async with pool.acquire() as conn:
@@ -1024,7 +1093,7 @@ class PostgresStorageBackend(StorageBackend):
         offset: int = 0,
     ) -> list[Schedule]:
         """List schedules with optional filtering."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         conditions = []
         params: list[Any] = []
@@ -1057,7 +1126,7 @@ class PostgresStorageBackend(StorageBackend):
 
     async def get_due_schedules(self, now: datetime) -> list[Schedule]:
         """Get all schedules that are due to run."""
-        pool = self._ensure_connected()
+        pool = await self._get_pool()
 
         async with pool.acquire() as conn:
             rows = await conn.fetch(

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

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

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

@@ -1,14 +1,15 @@
-pyworkflow/__init__.py,sha256=8Flustr4-f69ZOy2pyXr9HyTF8FuxRUgADYW3UwgXQk,6281
-pyworkflow/config.py,sha256=vNx6ETj78P_e4FxTG_zbh54W0IyF1MM1AU4ayuS2Bz8,14305
+pyworkflow/__init__.py,sha256=q49wycfPtEoYrdpy3Ic-ox-k1f_zUw1NaOjUvO3EuRU,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/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=EsmRqervXqnJn7Jl76ZDV9OIcNnIb6fRjDeuZEfYJL8,6456
+pyworkflow/celery/app.py,sha256=sIbnz40KGIvPC84f7X-Ds7_GvFhzOZOciSeslk57Cig,9223
+pyworkflow/celery/loop.py,sha256=mu8cIfMJYgHAoGCN_DdDoNoXK3QHzHpLmrPCyFDQYIY,3016
 pyworkflow/celery/scheduler.py,sha256=Ms4rqRpdpMiLM8l4y3DK-Divunj9afYuUaGGoNQe7P4,11288
-pyworkflow/celery/tasks.py,sha256=HJXwJjlhWu9aKQKZn4Os8b3y5OOHK9CUnHMH6xVnlyk,64740
+pyworkflow/celery/tasks.py,sha256=gPdZZ0YOpqPVcj4fNgwVreSKf8gAGaw6v2yGZyYrUvA,82663
 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
@@ -18,7 +19,7 @@ pyworkflow/cli/commands/runs.py,sha256=dkAx0WSBLyooD-vUUDPqgrmM3ElFwqO4nycEZGkNq
 pyworkflow/cli/commands/scheduler.py,sha256=w2iUoJ1CtEtOg_4TWslTHbzEPVsV-YybqWU9jkf38gs,3706
 pyworkflow/cli/commands/schedules.py,sha256=UCKZLTWsiLwCewCEXmqOVQnptvvuIKsWSTXai61RYbM,23466
 pyworkflow/cli/commands/setup.py,sha256=J-9lvz3m2sZiiLzQtQIfjmX0l8IpJ4L-xp5U4P7UmRY,32256
-pyworkflow/cli/commands/worker.py,sha256=UJ8bQJTXMEk3BoMiivClTCKNt_f-g75jJ5O-khfcfsY,12110
+pyworkflow/cli/commands/worker.py,sha256=PamHnEbgr2GQhFikyEEjT_Oai_iIvSs-a8GGXF4lHv0,12196
 pyworkflow/cli/commands/workflows.py,sha256=zRBFeqCa4Uo_wwEjgk0SBmkqgcaMznS6ghe1N0ub8Zs,42673
 pyworkflow/cli/output/__init__.py,sha256=5VxKL3mXah5rCKmctxcAKVwp42T47qT1oBK5LFVHHEg,48
 pyworkflow/cli/output/formatters.py,sha256=QzsgPR3cjIbH0723wuG_HzUx9xC7XMA6-NkT2y2lwtM,8785
@@ -33,22 +34,22 @@ 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=sq2L5odO3IIzgAd_I_ww1-3hCOe3tyJtjrunriPAI7o,13570
-pyworkflow/context/local.py,sha256=jXlY5h3EisP-7TqNVUSMi7mzHOCZNjAMZgCNf6R5OfU,35991
+pyworkflow/context/base.py,sha256=Hlfm5MNHh_BVbRCgEcILmHiqsn81iYFqt0GSLkFGo00,13772
+pyworkflow/context/local.py,sha256=H9UTuIWjelP4Nsc16guDf_fSMxVsIyfzbymJclvADhw,37118
 pyworkflow/context/mock.py,sha256=TJzQ3P3_ZHm1lCJZJACIFFvz2ydFxz2cT9eEGOQS5I0,12061
-pyworkflow/context/step_context.py,sha256=fW0I1t5A-rWqaBN85MNlNmSLAs3W-qf4arcYne0J4Xw,9261
+pyworkflow/context/step_context.py,sha256=6P2jn1v7MTlYaWCTt6DBq7Nkmxm7nvna4oGpTZJeMbg,8862
 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=RY7i0j44Gjg2aziLrnSpdz63fn5GFas4XVb-PTZw2jQ,22473
+pyworkflow/core/step.py,sha256=8S_O_KVoaCJSkE5oUslj8orR-S4qSR6_vQoE0NtZ4dU,23463
 pyworkflow/core/workflow.py,sha256=dlcICq1B69-nxUJth_n-H8U9TjP3QZyjvquQXxWHcxs,12076
 pyworkflow/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyworkflow/engine/events.py,sha256=-ix7EZnNRLfSRk4GJAl5-18uela0BDoCghI_4p5UVKc,25114
-pyworkflow/engine/executor.py,sha256=5b50m-a4XjrOoIS9hS4Rsgk_N114s5js6b-LuW2L0Jw,20333
-pyworkflow/engine/replay.py,sha256=SYHR5PkbyZp1cUdGNwbzx-VKNHus7-SohCR6Tox26vA,10875
+pyworkflow/engine/events.py,sha256=KFtyIqQjr1B9Frtd5V1Zq0ph1iwg_Ky3uPzmTYZ1Tnk,25827
+pyworkflow/engine/executor.py,sha256=l2HlpQfqzSL_0WuTFb1c4pEIgYU9JcN792hkGICqCAk,21109
+pyworkflow/engine/replay.py,sha256=bmMb4wzPKaZwPOage3Z-g_5DndYNoSmavMZ9sPiFzYI,9386
 pyworkflow/observability/__init__.py,sha256=M_Uc3WdtshQSxLnj3T8D0M7f4zcCuFzVs8e8PKCuXDc,380
-pyworkflow/observability/logging.py,sha256=4b_N4bIHUxlgOzEn5u1uB-ngCWPNDSU7daKAKxkjBUM,7018
+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
@@ -61,9 +62,9 @@ pyworkflow/primitives/shield.py,sha256=MUYakU0euZoYNb6MbFyRfJN8GEXsRFkIbZEo84vRN
 pyworkflow/primitives/sleep.py,sha256=iH1e5CoWY-jZbYNAU3GRW1xR_8EtCuPIcIohzU4jWJo,3097
 pyworkflow/runtime/__init__.py,sha256=DkwTgFCMRGyyW8NGcW7Nyy9beOg5kO1TXhqhysj1-aY,649
 pyworkflow/runtime/base.py,sha256=-X2pct03XuA3o1P6yD5ywTDgegN6_a450gG8MBVeKRE,5190
-pyworkflow/runtime/celery.py,sha256=0hSwN4alL69ZgnIgYiITcJ0s_iTi8A_xrsdKo89k4Hs,9431
+pyworkflow/runtime/celery.py,sha256=FMxiLiRf1pLWD7itEyd6klrH8PjSUOLTxWd7E8TyOG4,9476
 pyworkflow/runtime/factory.py,sha256=TRbqWPfyZ0tPFKb0faI9SkBRXxE5AEVTwGW4pS2diM8,2684
-pyworkflow/runtime/local.py,sha256=WsjaNcS_aJKLIdglaukeOj_YZqrQ75glsv1MeqS6VhM,24128
+pyworkflow/runtime/local.py,sha256=8mhUyMJDseXFsO0XvwJN6QkXd_4tjPEHG1_N_BmJgsE,25868
 pyworkflow/scheduler/__init__.py,sha256=lQQo0Cia_ULIg-KPIrqILV30rUIzybxj1k_ZZTQNZyg,222
 pyworkflow/scheduler/local.py,sha256=CnK4UC6ofD3_AZJUlO9iUAdgAnbMmJvPaL_VucNKs5Q,8154
 pyworkflow/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -72,20 +73,20 @@ pyworkflow/serialization/encoder.py,sha256=ZBwAxe5Bb4MCfFJePHw7ArJlIbBieSwUgsysG
 pyworkflow/storage/__init__.py,sha256=LhVjLNZdo4Mi5dEC75hjSPnbQr9jBoIsTOrC8vzTGOM,1924
 pyworkflow/storage/base.py,sha256=DxgOB9kr3i1uaitY_E9PzhnNWxaq1U5EvbbSjKyoH8M,16104
 pyworkflow/storage/cassandra.py,sha256=Nig0SUlTyxuNgPjOXnVBlzDq3PAGci4jIT1JI0i-GOk,61428
-pyworkflow/storage/config.py,sha256=M5s0ekcGN1Hnj0UkIeaHE4-n-SpsyawN47LyKxKnIqo,9787
+pyworkflow/storage/config.py,sha256=45UMPxRoqgK4ZwE7HIK9ctxE_eoK3eAE_1tRhn3Psd4,12410
 pyworkflow/storage/dynamodb.py,sha256=tGNQQqESxhZzOP5NJULCZKcQf9UuSQNL17TJo6R1jlw,53301
 pyworkflow/storage/file.py,sha256=lKilavXn_CRiIVL5XeV7tY9lm2vJADH-h9Teg0gA84A,28842
 pyworkflow/storage/memory.py,sha256=r2z6LiRw8J2AbO9Qw2wtYjzGfX-VJlRX_RVI2U8c-hs,19753
 pyworkflow/storage/mysql.py,sha256=f1aGyAL8fGsLnmHkpEwP4MFSwvYTpQxOBECHKCnetGI,42904
-pyworkflow/storage/postgres.py,sha256=s9NRBBHRhCOWbqhhg6vXe_8oX8ld0BgrsKW131j0A5s,41327
+pyworkflow/storage/postgres.py,sha256=KrDVF715YSEFouNVQOG6g-ekNvkTtrNxqWSvJMYueeM,44450
 pyworkflow/storage/schemas.py,sha256=o1ntTYNgQQ5YVuXtPCShtENEsndVjdrXclWrkCgkitg,18002
 pyworkflow/storage/sqlite.py,sha256=oBzJnnOp2uk0-U7hMTQk9QgJq3RBwXPQfrmYpivjdgE,39529
 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.11.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
-pyworkflow_engine-0.1.11.dist-info/METADATA,sha256=21A9CRqCgkH3ZcCUlhQ-99-LaSsozsIlAPk-aZK7QPg,19628
-pyworkflow_engine-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyworkflow_engine-0.1.11.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
-pyworkflow_engine-0.1.11.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
-pyworkflow_engine-0.1.11.dist-info/RECORD,,
+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,,