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

pyworkflow/storage/memory.py

@@ -43,10 +43,10 @@ class InMemoryStorageBackend(StorageBackend):
         self._runs: dict[str, WorkflowRun] = {}
         self._events: dict[str, list[Event]] = {}
         self._steps: dict[str, StepExecution] = {}
-        self._hooks: dict[str, Hook] = {}
+        self._hooks: dict[tuple[str, str], Hook] = {}  # (run_id, hook_id) -> Hook
         self._schedules: dict[str, Schedule] = {}
         self._idempotency_index: dict[str, str] = {}  # key -> run_id
-        self._token_index: dict[str, str] = {}  # token -> hook_id
+        self._token_index: dict[str, tuple[str, str]] = {}  # token -> (run_id, hook_id)
         self._cancellation_flags: dict[str, bool] = {}  # run_id -> cancelled
         self._lock = threading.RLock()
         self._event_sequences: dict[str, int] = {}  # run_id -> next sequence
@@ -292,20 +292,28 @@ class InMemoryStorageBackend(StorageBackend):
     async def create_hook(self, hook: Hook) -> None:
         """Create a hook record."""
         with self._lock:
-            self._hooks[hook.hook_id] = hook
-            self._token_index[hook.token] = hook.hook_id
+            key = (hook.run_id, hook.hook_id)
+            self._hooks[key] = hook
+            self._token_index[hook.token] = key
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         with self._lock:
-            return self._hooks.get(hook_id)
+            if run_id:
+                return self._hooks.get((run_id, hook_id))
+            else:
+                # Fallback: find any hook with this ID (may return wrong one if duplicates)
+                for (_r_id, h_id), hook in self._hooks.items():
+                    if h_id == hook_id:
+                        return hook
+                return None
 
     async def get_hook_by_token(self, token: str) -> Hook | None:
         """Retrieve a hook by its token."""
         with self._lock:
-            hook_id = self._token_index.get(token)
-            if hook_id:
-                return self._hooks.get(hook_id)
+            key = self._token_index.get(token)
+            if key:
+                return self._hooks.get(key)
             return None
 
     async def update_hook_status(
@@ -313,10 +321,19 @@ class InMemoryStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         with self._lock:
-            hook = self._hooks.get(hook_id)
+            if run_id:
+                hook = self._hooks.get((run_id, hook_id))
+            else:
+                # Fallback: find any hook with this ID
+                hook = None
+                for (_r_id, h_id), h in self._hooks.items():
+                    if h_id == hook_id:
+                        hook = h
+                        break
             if hook:
                 hook.status = status
                 if payload is not None:

pyworkflow/storage/mysql.py

@@ -175,11 +175,11 @@ class MySQLStorageBackend(StorageBackend):
                     ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
                 """)
 
-            # Hooks table
+            # Hooks table (composite PK: run_id + hook_id since hook_id is only unique per run)
             await cur.execute("""
                     CREATE TABLE IF NOT EXISTS hooks (
-                        hook_id VARCHAR(255) PRIMARY KEY,
                         run_id VARCHAR(255) NOT NULL,
+                        hook_id VARCHAR(255) NOT NULL,
                         token VARCHAR(255) UNIQUE NOT NULL,
                         created_at DATETIME(6) NOT NULL,
                         received_at DATETIME(6),
@@ -187,6 +187,7 @@ class MySQLStorageBackend(StorageBackend):
                         status VARCHAR(50) NOT NULL,
                         payload LONGTEXT,
                         metadata LONGTEXT DEFAULT '{}',
+                        PRIMARY KEY (run_id, hook_id),
                         UNIQUE INDEX idx_hooks_token (token),
                         INDEX idx_hooks_run_id (run_id),
                         INDEX idx_hooks_status (status),
@@ -660,12 +661,19 @@ class MySQLStorageBackend(StorageBackend):
                 ),
             )
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         pool = self._ensure_connected()
 
         async with pool.acquire() as conn, conn.cursor(aiomysql.DictCursor) as cur:
-            await cur.execute("SELECT * FROM hooks WHERE hook_id = %s", (hook_id,))
+            if run_id:
+                await cur.execute(
+                    "SELECT * FROM hooks WHERE run_id = %s AND hook_id = %s",
+                    (run_id, hook_id),
+                )
+            else:
+                # Fallback: find any hook with this ID (may return wrong one if duplicates)
+                await cur.execute("SELECT * FROM hooks WHERE hook_id = %s", (hook_id,))
             row = await cur.fetchone()
 
         if not row:
@@ -691,6 +699,7 @@ class MySQLStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         pool = self._ensure_connected()
@@ -706,13 +715,20 @@ class MySQLStorageBackend(StorageBackend):
             updates.append("received_at = %s")
             params.append(datetime.now(UTC))
 
-        params.append(hook_id)
-
         async with pool.acquire() as conn, conn.cursor() as cur:
-            await cur.execute(
-                f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = %s",
-                tuple(params),
-            )
+            if run_id:
+                params.append(run_id)
+                params.append(hook_id)
+                await cur.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE run_id = %s AND hook_id = %s",
+                    tuple(params),
+                )
+            else:
+                params.append(hook_id)
+                await cur.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = %s",
+                    tuple(params),
+                )
 
     async def list_hooks(
         self,

pyworkflow/storage/postgres.py

@@ -216,18 +216,19 @@ class PostgresStorageBackend(StorageBackend):
             # Indexes for steps
             await conn.execute("CREATE INDEX IF NOT EXISTS idx_steps_run_id ON steps(run_id)")
 
-            # Hooks table
+            # Hooks table (composite PK: run_id + hook_id since hook_id is only unique per run)
             await conn.execute("""
                 CREATE TABLE IF NOT EXISTS hooks (
-                    hook_id TEXT PRIMARY KEY,
                     run_id TEXT NOT NULL REFERENCES workflow_runs(run_id) ON DELETE CASCADE,
+                    hook_id TEXT NOT NULL,
                     token TEXT UNIQUE NOT NULL,
                     created_at TIMESTAMPTZ NOT NULL,
                     received_at TIMESTAMPTZ,
                     expires_at TIMESTAMPTZ,
                     status TEXT NOT NULL,
                     payload TEXT,
-                    metadata TEXT DEFAULT '{}'
+                    metadata TEXT DEFAULT '{}',
+                    PRIMARY KEY (run_id, hook_id)
                 )
             """)
 
@@ -751,12 +752,20 @@ class PostgresStorageBackend(StorageBackend):
                 json.dumps(hook.metadata),
             )
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         pool = await self._get_pool()
 
         async with pool.acquire() as conn:
-            row = await conn.fetchrow("SELECT * FROM hooks WHERE hook_id = $1", hook_id)
+            if run_id:
+                row = await conn.fetchrow(
+                    "SELECT * FROM hooks WHERE run_id = $1 AND hook_id = $2",
+                    run_id,
+                    hook_id,
+                )
+            else:
+                # Fallback: find any hook with this ID (may return wrong one if duplicates)
+                row = await conn.fetchrow("SELECT * FROM hooks WHERE hook_id = $1", hook_id)
 
         if not row:
             return None
@@ -780,6 +789,7 @@ class PostgresStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         pool = await self._get_pool()
@@ -798,13 +808,20 @@ class PostgresStorageBackend(StorageBackend):
             params.append(datetime.now(UTC))
             param_idx += 1
 
-        params.append(hook_id)
-
         async with pool.acquire() as conn:
-            await conn.execute(
-                f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ${param_idx}",
-                *params,
-            )
+            if run_id:
+                params.append(run_id)
+                params.append(hook_id)
+                await conn.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE run_id = ${param_idx} AND hook_id = ${param_idx + 1}",
+                    *params,
+                )
+            else:
+                params.append(hook_id)
+                await conn.execute(
+                    f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ${param_idx}",
+                    *params,
+                )
 
     async def list_hooks(
         self,

pyworkflow/storage/sqlite.py

@@ -164,11 +164,11 @@ class SQLiteStorageBackend(StorageBackend):
         # Indexes for steps
         await db.execute("CREATE INDEX IF NOT EXISTS idx_steps_run_id ON steps(run_id)")
 
-        # Hooks table
+        # Hooks table (composite PK: run_id + hook_id since hook_id is only unique per run)
         await db.execute("""
             CREATE TABLE IF NOT EXISTS hooks (
-                hook_id TEXT PRIMARY KEY,
                 run_id TEXT NOT NULL,
+                hook_id TEXT NOT NULL,
                 token TEXT UNIQUE NOT NULL,
                 created_at TIMESTAMP NOT NULL,
                 received_at TIMESTAMP,
@@ -176,6 +176,7 @@ class SQLiteStorageBackend(StorageBackend):
                 status TEXT NOT NULL,
                 payload TEXT,
                 metadata TEXT DEFAULT '{}',
+                PRIMARY KEY (run_id, hook_id),
                 FOREIGN KEY (run_id) REFERENCES workflow_runs(run_id) ON DELETE CASCADE
             )
         """)
@@ -645,12 +646,20 @@ class SQLiteStorageBackend(StorageBackend):
         )
         await db.commit()
 
-    async def get_hook(self, hook_id: str) -> Hook | None:
-        """Retrieve a hook by ID."""
+    async def get_hook(self, hook_id: str, run_id: str | None = None) -> Hook | None:
+        """Retrieve a hook by ID (requires run_id for composite key lookup)."""
         db = self._ensure_connected()
 
-        async with db.execute("SELECT * FROM hooks WHERE hook_id = ?", (hook_id,)) as cursor:
-            row = await cursor.fetchone()
+        if run_id:
+            async with db.execute(
+                "SELECT * FROM hooks WHERE run_id = ? AND hook_id = ?",
+                (run_id, hook_id),
+            ) as cursor:
+                row = await cursor.fetchone()
+        else:
+            # Fallback: find any hook with this ID (may return wrong one if duplicates)
+            async with db.execute("SELECT * FROM hooks WHERE hook_id = ?", (hook_id,)) as cursor:
+                row = await cursor.fetchone()
 
         if not row:
             return None
@@ -674,6 +683,7 @@ class SQLiteStorageBackend(StorageBackend):
         hook_id: str,
         status: HookStatus,
         payload: str | None = None,
+        run_id: str | None = None,
     ) -> None:
         """Update hook status and optionally payload."""
         db = self._ensure_connected()
@@ -689,12 +699,19 @@ class SQLiteStorageBackend(StorageBackend):
             updates.append("received_at = ?")
             params.append(datetime.now(UTC).isoformat())
 
-        params.append(hook_id)
-
-        await db.execute(
-            f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ?",
-            tuple(params),
-        )
+        if run_id:
+            params.append(run_id)
+            params.append(hook_id)
+            await db.execute(
+                f"UPDATE hooks SET {', '.join(updates)} WHERE run_id = ? AND hook_id = ?",
+                tuple(params),
+            )
+        else:
+            params.append(hook_id)
+            await db.execute(
+                f"UPDATE hooks SET {', '.join(updates)} WHERE hook_id = ?",
+                tuple(params),
+            )
         await db.commit()
 
     async def list_hooks(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyworkflow-engine
-Version: 0.1.12
+Version: 0.1.14
 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.14.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyworkflow/__init__.py,sha256=q49wycfPtEoYrdpy3Ic-ox-k1f_zUw1NaOjUvO3EuRU,6281
+pyworkflow/__init__.py,sha256=_VlxxYt3VmBKyIU9jbX7QfZ8DEHbNTU6UhogeO-Gm-s,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=J4a5LY5GsSFbO2evkql4Pw7h38tA2rQbR3J2cXkJRZg,13155
+pyworkflow/celery/tasks.py,sha256=BNHZwWTSRc3q8EgAy4tEmXAm6O0vtVLgrG7MrO0ZZXA,86049
 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,14 +36,15 @@ pyworkflow/cli/utils/storage.py,sha256=a5Iu2Xe1_mPgBVYc8B6I63MFfW12ko7wURqcpq3RB
 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=H9UTuIWjelP4Nsc16guDf_fSMxVsIyfzbymJclvADhw,37118
+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/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
@@ -56,37 +58,37 @@ pyworkflow/primitives/child_workflow.py,sha256=_T7PCqiH0tjIm_lpJ6NmfUPWCFx-MjH6t
 pyworkflow/primitives/continue_as_new.py,sha256=NKcimHsgr5ExkvRvfO28hxgPw_I7Q74Vz9WL8r0PhPc,3329
 pyworkflow/primitives/define_hook.py,sha256=gNzk7DuObfWG1T9AdHnDnGLHNKjnApiVRlCKPObugfY,4443
 pyworkflow/primitives/hooks.py,sha256=ws9U81ymsY8M4FFTvJ2X4EMGmIrilb3vCKZ0V_EGZdE,3085
-pyworkflow/primitives/resume_hook.py,sha256=q6gb0qsAhOkFRKMs-PkbLSFLnLerx0VGMkPp9CbkXZQ,6192
+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/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=FMxiLiRf1pLWD7itEyd6klrH8PjSUOLTxWd7E8TyOG4,9476
+pyworkflow/runtime/base.py,sha256=ATlPeheYzUMlk_v-9abLyUQf4y4iYB53VpaoQ73pYsc,5465
+pyworkflow/runtime/celery.py,sha256=JadRjmpL1rsp-zNAHq3vL8XdAhKucu1vEsxGvshaLjk,9961
 pyworkflow/runtime/factory.py,sha256=TRbqWPfyZ0tPFKb0faI9SkBRXxE5AEVTwGW4pS2diM8,2684
-pyworkflow/runtime/local.py,sha256=8mhUyMJDseXFsO0XvwJN6QkXd_4tjPEHG1_N_BmJgsE,25868
+pyworkflow/runtime/local.py,sha256=UPOdJsejrWzdz5p1XpTfMgWC0EK85qT7HHBUjmJ4xOQ,26228
 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
 pyworkflow/serialization/decoder.py,sha256=F7Ofuw1Yzo82iSFFXiK2yoW_v2YRbLMpX3CQbKjm0Ls,3860
 pyworkflow/serialization/encoder.py,sha256=ZBwAxe5Bb4MCfFJePHw7ArJlIbBieSwUgsysGCI2iPU,4108
 pyworkflow/storage/__init__.py,sha256=LhVjLNZdo4Mi5dEC75hjSPnbQr9jBoIsTOrC8vzTGOM,1924
-pyworkflow/storage/base.py,sha256=DxgOB9kr3i1uaitY_E9PzhnNWxaq1U5EvbbSjKyoH8M,16104
-pyworkflow/storage/cassandra.py,sha256=Nig0SUlTyxuNgPjOXnVBlzDq3PAGci4jIT1JI0i-GOk,61428
+pyworkflow/storage/base.py,sha256=ZS0jTdBRmT4nhADIPpr_MmOvqQvhse3LSb6CDt5rr-4,16324
+pyworkflow/storage/cassandra.py,sha256=DTJJr4yqAV-941YjQQdoO1-5SsFoqke82sXpBrXPyKg,61741
 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=KrDVF715YSEFouNVQOG6g-ekNvkTtrNxqWSvJMYueeM,44450
+pyworkflow/storage/dynamodb.py,sha256=8ClKZeP3TURDVJN2SJMAoLWWSXAgqysQXnqUXoRhaos,54159
+pyworkflow/storage/file.py,sha256=g2eO-MOaQKliM97_gTVGPS27GmH5mahi5GBZ99RP8Rs,30133
+pyworkflow/storage/memory.py,sha256=J5ZA2DsXE5tEQDn5dmtJ3mNEWy9okR6sTYZ-xp3slWY,20554
+pyworkflow/storage/mysql.py,sha256=lA2TRBvYlWEq5mQcnfyRivFO1n0kviq_yH3mEzGp8rs,43764
+pyworkflow/storage/postgres.py,sha256=GUW2OjV6CHWi9fUkUPswmGwvaY7c76QxIQ9kRL8BM6o,45351
 pyworkflow/storage/schemas.py,sha256=o1ntTYNgQQ5YVuXtPCShtENEsndVjdrXclWrkCgkitg,18002
-pyworkflow/storage/sqlite.py,sha256=oBzJnnOp2uk0-U7hMTQk9QgJq3RBwXPQfrmYpivjdgE,39529
+pyworkflow/storage/sqlite.py,sha256=qDhFjyFAenwYq6MF_66FFhDaBG7CEr7ni9Uy72X7MvQ,40377
 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.14.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
+pyworkflow_engine-0.1.14.dist-info/METADATA,sha256=9-fZ4yxwmOu2fjwAIYAaDqrlBqE_F4WRFsSTwt-6JaY,19628
+pyworkflow_engine-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyworkflow_engine-0.1.14.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
+pyworkflow_engine-0.1.14.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
+pyworkflow_engine-0.1.14.dist-info/RECORD,,