pyworkflow-engine 0.2.11__tar.gz → 0.2.13__tar.gz

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/PKG-INFO

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

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyproject.toml

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

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/__init__.py

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

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/celery/app.py

@@ -84,9 +84,7 @@ def _run_startup_migrations() -> None:
     from loguru import logger as loguru_logger
 
     if os.getenv("PYWORKFLOW_SKIP_STARTUP_MIGRATIONS", "").lower() in ("1", "true", "yes"):
-        loguru_logger.info(
-            "STARTUP_MIGRATIONS: skipped (PYWORKFLOW_SKIP_STARTUP_MIGRATIONS set)"
-        )
+        loguru_logger.info("STARTUP_MIGRATIONS: skipped (PYWORKFLOW_SKIP_STARTUP_MIGRATIONS set)")
         return
 
     from pyworkflow.config import _load_env_storage_config
@@ -134,7 +132,16 @@ def _run_startup_migrations() -> None:
         )
         raise
 
-    loguru_logger.info("STARTUP_MIGRATIONS: completed successfully")
+    # Declare that the schema is up-to-date in this process. Forked worker
+    # children inherit the flag via copy-on-write, so every runtime connect()
+    # in this pod will skip _initialize_schema() / run_migrations() entirely.
+    from pyworkflow.storage.config import mark_schema_ensured
+
+    mark_schema_ensured()
+
+    loguru_logger.info(
+        "STARTUP_MIGRATIONS: completed successfully — runtime connects will skip schema init"
+    )
 
 
 def is_sentinel_url(url: str) -> bool:
@@ -413,7 +420,7 @@ def create_celery_app(
             },
             "pyworkflow-streams-drain-scheduled": {
                 "task": "pyworkflow.streams.drain_scheduled_signals",
-                "schedule": timedelta(seconds=2),
+                "schedule": timedelta(seconds=30),
                 "options": {"queue": "pyworkflow.default"},
             },
         },

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/celery/tasks.py

@@ -2832,7 +2832,7 @@ def run_data_retention_task(self: SingletonWorkflowTask) -> dict[str, Any]:
 
     cutoff = datetime.now(UTC) - timedelta(days=config.data_retention_days)
     logger.info(
-        "Running data retention: deleting runs updated before {}",
+        "Running data retention: deleting runs and orphaned stream data older than {}",
         cutoff.isoformat(),
     )
     storage_config = storage_to_config(storage)

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/base.py

@@ -707,7 +707,14 @@ class StorageBackend(ABC):
         Delete workflow runs in terminal states last updated before `older_than`.
 
         Terminal states: COMPLETED, FAILED, CANCELLED, CONTINUED_AS_NEW, INTERRUPTED.
-        Associated events, steps, hooks, and cancellation flags are deleted too.
+
+        Deletes the following associated data:
+        - events, steps, checkpoints, hooks, cancellation_flags (by run_id)
+        - signals (published_at < older_than)
+        - signal_acknowledgments (acknowledged_at < older_than)
+        - scheduled_signals (delivered + created_at < older_than)
+        - stream_subscriptions (terminated/completed + created_at < older_than)
+        - schedules (soft-deleted + deleted_at/updated_at < older_than)
 
         Args:
             older_than: Delete runs where updated_at < older_than

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/cassandra.py

@@ -1876,6 +1876,94 @@ class CassandraStorageBackend(StorageBackend):
                 )
                 count += 1
 
+        # --- Stream / schedule cleanup ---
+        # ALLOW FILTERING is acceptable here: this is a background retention
+        # job that runs at most once per day.
+        sig_rows = session.execute(
+            SimpleStatement(
+                "SELECT stream_id, stream_run_id, sequence FROM signals "
+                "WHERE published_at < %s ALLOW FILTERING",
+                consistency_level=self.read_consistency,
+            ),
+            (older_than,),
+        )
+        for sr in sig_rows:
+            session.execute(
+                SimpleStatement(
+                    "DELETE FROM signals WHERE stream_id = %s "
+                    "AND stream_run_id = %s AND sequence = %s",
+                    consistency_level=self.write_consistency,
+                ),
+                (sr.stream_id, sr.stream_run_id, sr.sequence),
+            )
+
+        ack_rows = session.execute(
+            SimpleStatement(
+                "SELECT signal_id, step_run_id FROM signal_acknowledgments "
+                "WHERE acknowledged_at < %s ALLOW FILTERING",
+                consistency_level=self.read_consistency,
+            ),
+            (older_than,),
+        )
+        for ar in ack_rows:
+            session.execute(
+                SimpleStatement(
+                    "DELETE FROM signal_acknowledgments WHERE signal_id = %s AND step_run_id = %s",
+                    consistency_level=self.write_consistency,
+                ),
+                (ar.signal_id, ar.step_run_id),
+            )
+
+        sub_rows = session.execute(
+            SimpleStatement(
+                "SELECT stream_id, step_run_id FROM stream_subscriptions "
+                "WHERE status IN ('terminated','completed') "
+                "AND created_at < %s ALLOW FILTERING",
+                consistency_level=self.read_consistency,
+            ),
+            (older_than,),
+        )
+        for sub in sub_rows:
+            session.execute(
+                SimpleStatement(
+                    "DELETE FROM stream_subscriptions WHERE stream_id = %s AND step_run_id = %s",
+                    consistency_level=self.write_consistency,
+                ),
+                (sub.stream_id, sub.step_run_id),
+            )
+
+        # Purge soft-deleted schedules
+        del_sched_rows = session.execute(
+            SimpleStatement(
+                "SELECT schedule_id FROM schedules_by_status WHERE status = 'DELETED'",
+                consistency_level=self.read_consistency,
+            ),
+        )
+        for ds in del_sched_rows:
+            sched_row = session.execute(
+                SimpleStatement(
+                    "SELECT updated_at FROM schedules WHERE schedule_id = %s",
+                    consistency_level=self.read_consistency,
+                ),
+                (ds.schedule_id,),
+            ).one()
+            if sched_row and sched_row.updated_at < older_than:
+                session.execute(
+                    SimpleStatement(
+                        "DELETE FROM schedules WHERE schedule_id = %s",
+                        consistency_level=self.write_consistency,
+                    ),
+                    (ds.schedule_id,),
+                )
+                session.execute(
+                    SimpleStatement(
+                        "DELETE FROM schedules_by_status "
+                        "WHERE status = 'DELETED' AND schedule_id = %s",
+                        consistency_level=self.write_consistency,
+                    ),
+                    (ds.schedule_id,),
+                )
+
         return count
 
     # Helper methods for converting Cassandra rows to domain objects

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/citus.py

@@ -189,8 +189,7 @@ class CitusMigrationRunner(PostgresMigrationRunner):
                 # V7: Add result column. Top-level ALTER for Citus propagation (see V5 note).
                 logger.info("CITUS_MIGRATION v7: ALTER stream_subscriptions ADD result")
                 await conn.execute(
-                    "ALTER TABLE stream_subscriptions "
-                    "ADD COLUMN IF NOT EXISTS result JSONB NULL"
+                    "ALTER TABLE stream_subscriptions ADD COLUMN IF NOT EXISTS result JSONB NULL"
                 )
             elif migration.up_func:
                 await migration.up_func(conn)

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/config.py

@@ -25,6 +25,55 @@ from pyworkflow.storage.base import StorageBackend
 _storage_cache: dict[str, tuple[StorageBackend, None]] = {}
 
 
+# ---------------------------------------------------------------------------
+# Schema-ensured signal
+# ---------------------------------------------------------------------------
+#
+# Process-global flag set by the Celery worker startup hook
+# (``pyworkflow.celery.app._run_startup_migrations``) after it has successfully
+# run pending migrations. When True, runtime ``connect()`` calls SKIP the
+# ``_initialize_schema()`` step entirely — no CREATE TABLE IF NOT EXISTS
+# sweep, no ``run_migrations()`` probe on the ``schema_versions`` table.
+#
+# Why a module-level flag rather than instance state or an env var:
+#   * Forked worker children inherit the flag via copy-on-write, so the
+#     parent process's "I already migrated" decision naturally propagates.
+#   * It's not an env var so child processes that shell out or subprocess
+#     don't accidentally carry the claim into an unrelated context.
+#   * Per-instance state would be reset on every loop change (pool recreate),
+#     so the flag must outlive backend instances.
+#
+# Paths that do NOT set the flag still get lazy initialization:
+#   * Tests that instantiate backends directly
+#   * CLI commands
+#   * Celery workers started with ``PYWORKFLOW_SKIP_STARTUP_MIGRATIONS=1``
+#   * Any caller that bypasses the startup hook
+_schema_ensured: bool = False
+
+
+def mark_schema_ensured() -> None:
+    """Declare that migrations are up-to-date in this process.
+
+    Called by the startup migration hook once migrations have been applied
+    successfully. After this, ``connect()`` on any Postgres/Citus backend
+    in this process (and in its fork children) will skip
+    ``_initialize_schema()``.
+    """
+    global _schema_ensured
+    _schema_ensured = True
+
+
+def is_schema_ensured() -> bool:
+    """Return True if the schema has already been ensured in this process."""
+    return _schema_ensured
+
+
+def reset_schema_ensured() -> None:
+    """Reset the flag. Intended for tests only."""
+    global _schema_ensured
+    _schema_ensured = False
+
+
 def _config_to_cache_key(config: dict[str, Any] | None) -> str:
     """
     Create a cache key from config dict.

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/dynamodb.py

@@ -1426,6 +1426,37 @@ class DynamoDBStorageBackend(StorageBackend):
 
                 count += 1
 
+            # --- Schedule cleanup: purge soft-deleted schedules ---
+            sched_params: dict[str, Any] = {
+                "TableName": self.table_name,
+                "IndexName": "GSI1",
+                "KeyConditionExpression": "GSI1PK = :pk",
+                "FilterExpression": "#st = :deleted AND updated_at < :cutoff",
+                "ExpressionAttributeNames": {"#st": "status"},
+                "ExpressionAttributeValues": {
+                    ":pk": {"S": "SCHEDULES"},
+                    ":deleted": {"S": "DELETED"},
+                    ":cutoff": {"S": cutoff_iso},
+                },
+                "ProjectionExpression": "PK, SK",
+            }
+            while True:
+                resp = await client.query(**sched_params)
+                items_to_delete = resp.get("Items", [])
+                for i in range(0, len(items_to_delete), 25):
+                    batch = items_to_delete[i : i + 25]
+                    request_items = {
+                        self.table_name: [
+                            {"DeleteRequest": {"Key": {"PK": it["PK"], "SK": it["SK"]}}}
+                            for it in batch
+                        ]
+                    }
+                    await client.batch_write_item(RequestItems=request_items)
+                lk = resp.get("LastEvaluatedKey")
+                if not lk:
+                    break
+                sched_params["ExclusiveStartKey"] = lk
+
         return count
 
     # Helper methods for converting DynamoDB items to domain objects

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/file.py

@@ -973,6 +973,7 @@ class FileStorageBackend(StorageBackend):
     async def delete_old_runs(self, older_than: datetime) -> int:
         """Delete terminal runs (and all related files) updated before older_than."""
         terminal = {"completed", "failed", "cancelled", "continued_as_new", "interrupted"}
+        cutoff_iso = older_than.isoformat()
 
         def _sync_delete() -> int:
             count = 0
@@ -994,6 +995,10 @@ class FileStorageBackend(StorageBackend):
                         try:
                             sd = json.loads(sf.read_text())
                             if sd.get("run_id") == run_id:
+                                # Also delete checkpoint for this step
+                                (self.checkpoints_dir / f"{sd['step_id']}.json").unlink(
+                                    missing_ok=True
+                                )
                                 sf.unlink(missing_ok=True)
                         except Exception:
                             pass
@@ -1003,6 +1008,48 @@ class FileStorageBackend(StorageBackend):
                     count += 1
                 except Exception:
                     continue
+
+            # --- Stream / schedule cleanup ---
+            # Prune old signals from each stream's signal file
+            for sig_file in list(self.signals_dir.glob("*.json")):
+                try:
+                    signals = json.loads(sig_file.read_text())
+                    kept = [s for s in signals if s.get("published_at", "") >= cutoff_iso]
+                    if len(kept) < len(signals):
+                        sig_file.write_text(json.dumps(kept, indent=2))
+                except Exception:
+                    pass
+
+            # Delete old terminal subscriptions
+            for sub_file in list(self.subscriptions_dir.glob("*.json")):
+                try:
+                    sub = json.loads(sub_file.read_text())
+                    if sub.get("status") in ("terminated", "completed"):
+                        if sub.get("created_at", "") < cutoff_iso:
+                            sub_file.unlink(missing_ok=True)
+                except Exception:
+                    pass
+
+            # Delete old acknowledgments
+            for ack_file in list(self.acknowledgments_dir.glob("*.json")):
+                try:
+                    ack = json.loads(ack_file.read_text())
+                    if ack.get("acknowledged_at", "") < cutoff_iso:
+                        ack_file.unlink(missing_ok=True)
+                except Exception:
+                    pass
+
+            # Purge soft-deleted schedules
+            for sched_file in list(self.schedules_dir.glob("*.json")):
+                try:
+                    sched = json.loads(sched_file.read_text())
+                    if sched.get("status") == "DELETED":
+                        deleted_at = sched.get("deleted_at") or sched.get("updated_at", "")
+                        if deleted_at and deleted_at < cutoff_iso:
+                            sched_file.unlink(missing_ok=True)
+                except Exception:
+                    pass
+
             return count
 
         return await asyncio.to_thread(_sync_delete)

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/memory.py

@@ -615,6 +615,7 @@ class InMemoryStorageBackend(StorageBackend):
             RunStatus.CONTINUED_AS_NEW,
             RunStatus.INTERRUPTED,
         }
+        cutoff_iso = older_than.isoformat()
         with self._lock:
             to_delete = [
                 run_id
@@ -629,12 +630,61 @@ class InMemoryStorageBackend(StorageBackend):
                     self._idempotency_index.pop(run.idempotency_key, None)
                 step_ids = [sid for sid, s in self._steps.items() if s.run_id == run_id]
                 for sid in step_ids:
+                    self._checkpoints.pop(sid, None)
                     del self._steps[sid]
                 hook_keys = [k for k in self._hooks if k[0] == run_id]
                 for k in hook_keys:
                     hook = self._hooks.pop(k)
                     self._token_index.pop(hook.token, None)
                 self._cancellation_flags.pop(run_id, None)
+
+            # --- Stream / schedule cleanup ---
+            # Purge old signals
+            for stream_id in list(self._signals):
+                self._signals[stream_id] = [
+                    s for s in self._signals[stream_id] if s.get("published_at", "") >= cutoff_iso
+                ]
+
+            # Purge delivered scheduled signals
+            if hasattr(self, "_scheduled_signals"):
+                to_remove = [
+                    sid for sid, row in self._scheduled_signals.items() if row["delivered"]
+                ]
+                for sid in to_remove:
+                    del self._scheduled_signals[sid]
+
+            # Purge terminal subscriptions
+            sub_to_remove = [
+                key
+                for key, sub in self._subscriptions.items()
+                if sub["status"] in ("terminated", "completed")
+                and sub.get("created_at", "") < cutoff_iso
+            ]
+            for key in sub_to_remove:
+                del self._subscriptions[key]
+
+            # Purge acknowledgments for signals that no longer exist
+            existing_signal_ids = set()
+            for sigs in self._signals.values():
+                for s in sigs:
+                    existing_signal_ids.add(s["signal_id"])
+            self._acknowledgments = {
+                (sig_id, step_id)
+                for sig_id, step_id in self._acknowledgments
+                if sig_id in existing_signal_ids
+            }
+
+            # Purge soft-deleted schedules
+            sched_to_remove = [
+                sid
+                for sid, sched in self._schedules.items()
+                if sched.status == ScheduleStatus.DELETED
+                and sched.updated_at is not None
+                and sched.updated_at < older_than
+            ]
+            for sid in sched_to_remove:
+                del self._schedules[sid]
+
             return len(to_delete)
 
     # Stream Operations

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/mysql.py

@@ -1422,11 +1422,34 @@ class MySQLStorageBackend(StorageBackend):
         async with pool.acquire() as conn:
             async with conn.cursor() as cur:
                 await cur.execute(f"DELETE FROM events WHERE run_id IN ({subq})", params)
+                step_subq = f"SELECT step_id FROM steps WHERE run_id IN ({subq})"
+                await cur.execute(
+                    f"DELETE FROM checkpoints WHERE step_run_id IN ({step_subq})", params
+                )
                 await cur.execute(f"DELETE FROM steps WHERE run_id IN ({subq})", params)
                 await cur.execute(f"DELETE FROM hooks WHERE run_id IN ({subq})", params)
                 await cur.execute(
                     f"DELETE FROM cancellation_flags WHERE run_id IN ({subq})", params
                 )
+
+                # --- Stream / schedule cleanup ---
+                await cur.execute(
+                    "DELETE FROM signals WHERE published_at < %s",
+                    (older_than,),
+                )
+                await cur.execute(
+                    "DELETE FROM signal_acknowledgments WHERE acknowledged_at < %s",
+                    (older_than,),
+                )
+                await cur.execute(
+                    "DELETE FROM stream_subscriptions WHERE status IN (%s,%s) AND created_at < %s",
+                    ("terminated", "completed", older_than),
+                )
+                await cur.execute(
+                    "DELETE FROM schedules WHERE status = 'DELETED' AND deleted_at < %s",
+                    (older_than,),
+                )
+
                 await cur.execute(
                     f"DELETE FROM workflow_runs WHERE status IN ({placeholders}) AND updated_at < %s",
                     params,

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/postgres.py

@@ -229,8 +229,7 @@ class PostgresMigrationRunner(MigrationRunner):
                 # V7: result column on stream_subscriptions for step output payloads.
                 logger.info("PG_MIGRATION v7: ALTER stream_subscriptions ADD result")
                 await conn.execute(
-                    "ALTER TABLE stream_subscriptions "
-                    "ADD COLUMN IF NOT EXISTS result JSONB NULL"
+                    "ALTER TABLE stream_subscriptions ADD COLUMN IF NOT EXISTS result JSONB NULL"
                 )
             elif migration.up_func:
                 await migration.up_func(conn)
@@ -358,7 +357,19 @@ class PostgresStorageBackend(StorageBackend):
             self._pool_loop_id = current_loop_id
 
         if not self._initialized:
-            await self._initialize_schema()
+            # When the Celery worker startup hook has already run migrations
+            # for this process, skip _initialize_schema() entirely. The hook
+            # sets a module-level flag (see pyworkflow.storage.config) that
+            # survives fork via copy-on-write, so every runtime connect in
+            # this process and its children is a pure pool-create.
+            #
+            # Paths that do NOT go through the startup hook (tests, CLI,
+            # PYWORKFLOW_SKIP_STARTUP_MIGRATIONS=1) still initialize lazily
+            # here, preserving backwards compatibility.
+            from pyworkflow.storage.config import is_schema_ensured
+
+            if not is_schema_ensured():
+                await self._initialize_schema()
             self._initialized = True
 
     async def disconnect(self) -> None:
@@ -1651,8 +1662,14 @@ class PostgresStorageBackend(StorageBackend):
             await self.update_schedule(schedule)
 
     async def delete_old_runs(self, older_than: datetime) -> int:
-        """Delete terminal runs (and all related data) updated before older_than."""
+        """Delete terminal runs (and all related data) updated before older_than.
+
+        Also purges orphaned stream data (signals, acknowledgments, delivered
+        scheduled signals, terminal subscriptions) and soft-deleted schedules
+        older than the cutoff.
+        """
         terminal = ["completed", "failed", "cancelled", "continued_as_new", "interrupted"]
+        sub_terminal = ["terminated", "completed"]
         pool = await self._get_pool()
         async with pool.acquire() as conn, conn.transaction():
             subq = "SELECT run_id FROM workflow_runs WHERE status = ANY($1) AND updated_at < $2"
@@ -1670,6 +1687,30 @@ class PostgresStorageBackend(StorageBackend):
                 terminal,
                 older_than,
             )
+
+            # --- Stream / schedule cleanup ---
+            await conn.execute(
+                "DELETE FROM scheduled_signals WHERE delivered = TRUE AND created_at < $1",
+                older_than,
+            )
+            await conn.execute(
+                "DELETE FROM signals WHERE published_at < $1",
+                older_than,
+            )
+            await conn.execute(
+                "DELETE FROM signal_acknowledgments WHERE acknowledged_at < $1",
+                older_than,
+            )
+            await conn.execute(
+                "DELETE FROM stream_subscriptions WHERE status = ANY($1) AND created_at < $2",
+                sub_terminal,
+                older_than,
+            )
+            await conn.execute(
+                "DELETE FROM schedules WHERE status = 'DELETED' AND deleted_at < $1",
+                older_than,
+            )
+
             result = await conn.execute(
                 "DELETE FROM workflow_runs WHERE status = ANY($1) AND updated_at < $2",
                 terminal,

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/storage/sqlite.py

@@ -1399,12 +1399,32 @@ class SQLiteStorageBackend(StorageBackend):
             f"SELECT run_id FROM workflow_runs WHERE status IN ({placeholders}) AND updated_at < ?"
         )
         params = (*terminal, older_than.isoformat())
+        cutoff_iso = older_than.isoformat()
         async with db.cursor() as cur:
             await cur.execute(f"DELETE FROM events WHERE run_id IN ({subq})", params)
             await cur.execute(f"DELETE FROM steps WHERE run_id IN ({subq})", params)
             await cur.execute(f"DELETE FROM hooks WHERE run_id IN ({subq})", params)
             await cur.execute(f"DELETE FROM cancellation_flags WHERE run_id IN ({subq})", params)
             await cur.execute(f"DELETE FROM checkpoints WHERE step_run_id IN ({subq})", params)
+
+            # --- Stream / schedule cleanup ---
+            await cur.execute(
+                "DELETE FROM signals WHERE published_at < ?",
+                (cutoff_iso,),
+            )
+            await cur.execute(
+                "DELETE FROM signal_acknowledgments WHERE acknowledged_at < ?",
+                (cutoff_iso,),
+            )
+            await cur.execute(
+                "DELETE FROM stream_subscriptions WHERE status IN (?,?) AND created_at < ?",
+                ("terminated", "completed", cutoff_iso),
+            )
+            await cur.execute(
+                "DELETE FROM schedules WHERE status = 'DELETED' AND deleted_at < ?",
+                (cutoff_iso,),
+            )
+
             await cur.execute(
                 f"DELETE FROM workflow_runs WHERE status IN ({placeholders}) AND updated_at < ?",
                 params,

{pyworkflow_engine-0.2.11 → pyworkflow_engine-0.2.13}/pyworkflow/streams/__init__.py

@@ -28,8 +28,10 @@ from pyworkflow.streams.checkpoint import (  # noqa: F401
 )
 from pyworkflow.streams.consumer import StreamConsumer, poll_once  # noqa: F401
 from pyworkflow.streams.context import (  # noqa: F401
+    acknowledge_inbox_signal,
     get_checkpoint,
     get_current_signal,
+    poll_inbox,
     save_checkpoint,
     set_result,
     suspend,
@@ -73,6 +75,8 @@ __all__ = [
     "get_current_signal",
     "get_checkpoint",
     "save_checkpoint",
+    "poll_inbox",
+    "acknowledge_inbox_signal",
     # Checkpoint
     "CheckpointBackend",
     "DefaultCheckpointBackend",