pyworkflow-engine 0.1.22__py3-none-any.whl → 0.1.23__py3-none-any.whl

pyworkflow/storage/postgres.py

@@ -23,6 +23,7 @@ import asyncpg
 
 from pyworkflow.engine.events import Event, EventType
 from pyworkflow.storage.base import StorageBackend
+from pyworkflow.storage.migrations import Migration, MigrationRegistry, MigrationRunner
 from pyworkflow.storage.schemas import (
     Hook,
     HookStatus,
@@ -37,6 +38,115 @@ from pyworkflow.storage.schemas import (
 )
 
 
+class PostgresMigrationRunner(MigrationRunner):
+    """PostgreSQL-specific migration runner."""
+
+    def __init__(self, pool: asyncpg.Pool, registry: MigrationRegistry | None = None) -> None:
+        super().__init__(registry)
+        self._pool = pool
+
+    async def ensure_schema_versions_table(self) -> None:
+        """Create schema_versions table if it doesn't exist."""
+        async with self._pool.acquire() as conn:
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS schema_versions (
+                    version INTEGER PRIMARY KEY,
+                    applied_at TIMESTAMPTZ NOT NULL,
+                    description TEXT
+                )
+            """)
+
+    async def get_current_version(self) -> int:
+        """Get the highest applied migration version."""
+        async with self._pool.acquire() as conn:
+            row = await conn.fetchrow(
+                "SELECT COALESCE(MAX(version), 0) as version FROM schema_versions"
+            )
+            return row["version"] if row else 0
+
+    async def detect_existing_schema(self) -> bool:
+        """Check if the events table exists (pre-versioning database)."""
+        async with self._pool.acquire() as conn:
+            row = await conn.fetchrow("""
+                SELECT EXISTS (
+                    SELECT FROM information_schema.tables
+                    WHERE table_name = 'events'
+                ) as exists
+            """)
+            return row["exists"] if row else False
+
+    async def record_baseline_version(self, version: int, description: str) -> None:
+        """Record a baseline version without running migrations."""
+        async with self._pool.acquire() as conn:
+            await conn.execute(
+                """
+                INSERT INTO schema_versions (version, applied_at, description)
+                VALUES ($1, $2, $3)
+                ON CONFLICT (version) DO NOTHING
+                """,
+                version,
+                datetime.now(UTC),
+                description,
+            )
+
+    async def apply_migration(self, migration: Migration) -> None:
+        """Apply a migration with PostgreSQL-specific handling."""
+        async with self._pool.acquire() as conn, conn.transaction():
+            if migration.version == 2:
+                # V2: Add step_id column to events table
+                # First check if events table exists (fresh databases won't have it yet)
+                table_exists = await conn.fetchrow("""
+                    SELECT EXISTS (
+                        SELECT FROM information_schema.tables
+                        WHERE table_name = 'events'
+                    ) as exists
+                """)
+
+                if table_exists and table_exists["exists"]:
+                    # Use IF NOT EXISTS for idempotency
+                    await conn.execute("""
+                        DO $$
+                        BEGIN
+                            IF NOT EXISTS (
+                                SELECT 1 FROM information_schema.columns
+                                WHERE table_name = 'events' AND column_name = 'step_id'
+                            ) THEN
+                                ALTER TABLE events ADD COLUMN step_id TEXT;
+                            END IF;
+                        END $$
+                    """)
+
+                    # Create index for optimized has_event() queries
+                    await conn.execute("""
+                        CREATE INDEX IF NOT EXISTS idx_events_run_id_step_id_type
+                        ON events(run_id, step_id, type)
+                    """)
+
+                    # Backfill step_id from JSON data
+                    await conn.execute("""
+                        UPDATE events
+                        SET step_id = (data::jsonb)->>'step_id'
+                        WHERE step_id IS NULL
+                          AND (data::jsonb)->>'step_id' IS NOT NULL
+                    """)
+                # If table doesn't exist, schema will be created with step_id column
+            elif migration.up_func:
+                await migration.up_func(conn)
+            elif migration.up_sql and migration.up_sql != "SELECT 1":
+                await conn.execute(migration.up_sql)
+
+            # Record the migration
+            await conn.execute(
+                """
+                INSERT INTO schema_versions (version, applied_at, description)
+                VALUES ($1, $2, $3)
+                """,
+                migration.version,
+                datetime.now(UTC),
+                migration.description,
+            )
+
+
 class PostgresStorageBackend(StorageBackend):
     """
     PostgreSQL storage backend using asyncpg for async operations.
@@ -55,6 +165,8 @@ class PostgresStorageBackend(StorageBackend):
         database: str = "pyworkflow",
         min_pool_size: int = 1,
         max_pool_size: int = 10,
+        max_inactive_connection_lifetime: float = 1800.0,
+        command_timeout: float | None = 60.0,
     ):
         """
         Initialize PostgreSQL storage backend.
@@ -68,6 +180,9 @@ class PostgresStorageBackend(StorageBackend):
             database: Database name (used if dsn not provided)
             min_pool_size: Minimum connections in pool
             max_pool_size: Maximum connections in pool
+            max_inactive_connection_lifetime: How long (seconds) an idle connection can
+                                              stay in the pool before being closed. Default 1800s (30 min).
+            command_timeout: Default timeout (seconds) for queries. None for no timeout. Default 60s.
         """
         self.dsn = dsn
         self.host = host
@@ -77,6 +192,8 @@ class PostgresStorageBackend(StorageBackend):
         self.database = database
         self.min_pool_size = min_pool_size
         self.max_pool_size = max_pool_size
+        self.max_inactive_connection_lifetime = max_inactive_connection_lifetime
+        self.command_timeout = command_timeout
         self._pool: asyncpg.Pool | None = None
         self._pool_loop_id: int | None = None  # Track which loop the pool was created on
         self._initialized = False
@@ -111,6 +228,8 @@ class PostgresStorageBackend(StorageBackend):
                 dsn=self.dsn or self._build_dsn(),
                 min_size=self.min_pool_size,
                 max_size=self.max_pool_size,
+                max_inactive_connection_lifetime=self.max_inactive_connection_lifetime,
+                command_timeout=self.command_timeout,
             )
             self._pool_loop_id = current_loop_id
 
@@ -127,11 +246,16 @@ class PostgresStorageBackend(StorageBackend):
             self._initialized = False
 
     async def _initialize_schema(self) -> None:
-        """Create database tables if they don't exist."""
+        """Create database tables if they don't exist and run migrations."""
         if not self._pool:
             await self.connect()
 
         pool = await self._get_pool()
+
+        # Run migrations first (handles schema versioning)
+        runner = PostgresMigrationRunner(pool)
+        await runner.run_migrations()
+
         async with pool.acquire() as conn:
             # Workflow runs table
             await conn.execute("""
@@ -177,7 +301,7 @@ class PostgresStorageBackend(StorageBackend):
                 "CREATE INDEX IF NOT EXISTS idx_runs_parent_run_id ON workflow_runs(parent_run_id)"
             )
 
-            # Events table
+            # Events table (includes step_id column added in V2 migration)
             await conn.execute("""
                 CREATE TABLE IF NOT EXISTS events (
                     event_id TEXT PRIMARY KEY,
@@ -185,7 +309,8 @@ class PostgresStorageBackend(StorageBackend):
                     sequence INTEGER NOT NULL,
                     type TEXT NOT NULL,
                     timestamp TIMESTAMPTZ NOT NULL,
-                    data TEXT NOT NULL DEFAULT '{}'
+                    data TEXT NOT NULL DEFAULT '{}',
+                    step_id TEXT
                 )
             """)
 
@@ -193,7 +318,14 @@ class PostgresStorageBackend(StorageBackend):
             await conn.execute(
                 "CREATE INDEX IF NOT EXISTS idx_events_run_id_sequence ON events(run_id, sequence)"
             )
-            await conn.execute("CREATE INDEX IF NOT EXISTS idx_events_type ON events(type)")
+            # Composite index for get_events() with type filter
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_events_run_id_type ON events(run_id, type)"
+            )
+            # Optimized index for has_event() with step_id filter (V2 migration)
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_events_run_id_step_id_type ON events(run_id, step_id, type)"
+            )
 
             # Steps table
             await conn.execute("""
@@ -554,6 +686,9 @@ class PostgresStorageBackend(StorageBackend):
         """Record an event to the append-only event log."""
         pool = await self._get_pool()
 
+        # Extract step_id from event data for indexed column
+        step_id = event.data.get("step_id") if event.data else None
+
         async with pool.acquire() as conn, conn.transaction():
             # Get next sequence number and insert in a transaction
             row = await conn.fetchrow(
@@ -564,8 +699,8 @@ class PostgresStorageBackend(StorageBackend):
 
             await conn.execute(
                 """
-                INSERT INTO events (event_id, run_id, sequence, type, timestamp, data)
-                VALUES ($1, $2, $3, $4, $5, $6)
+                INSERT INTO events (event_id, run_id, sequence, type, timestamp, data, step_id)
+                VALUES ($1, $2, $3, $4, $5, $6, $7)
                 """,
                 event.event_id,
                 event.run_id,
@@ -573,6 +708,7 @@ class PostgresStorageBackend(StorageBackend):
                 event.type.value,
                 event.timestamp,
                 json.dumps(event.data),
+                step_id,
             )
 
     async def get_events(
@@ -638,6 +774,58 @@ class PostgresStorageBackend(StorageBackend):
 
         return self._row_to_event(row)
 
+    async def has_event(
+        self,
+        run_id: str,
+        event_type: str,
+        **filters: str,
+    ) -> bool:
+        """
+        Check if an event exists using optimized indexed queries.
+
+        When step_id is the only filter, uses a direct indexed query (O(1) lookup).
+        For other filters, falls back to loading events of the type and filtering in Python.
+
+        Args:
+            run_id: Workflow run identifier
+            event_type: Event type to check for
+            **filters: Additional filters for event data fields
+
+        Returns:
+            True if a matching event exists, False otherwise
+        """
+        pool = await self._get_pool()
+
+        # Optimized path: if only filtering by step_id, use indexed column directly
+        if filters.keys() == {"step_id"}:
+            step_id = str(filters["step_id"])
+            async with pool.acquire() as conn:
+                row = await conn.fetchrow(
+                    """
+                    SELECT 1 FROM events
+                    WHERE run_id = $1 AND type = $2 AND step_id = $3
+                    LIMIT 1
+                    """,
+                    run_id,
+                    event_type,
+                    step_id,
+                )
+            return row is not None
+
+        # Fallback: load events of type and filter in Python
+        events = await self.get_events(run_id, event_types=[event_type])
+
+        for event in events:
+            match = True
+            for key, value in filters.items():
+                if str(event.data.get(key)) != str(value):
+                    match = False
+                    break
+            if match:
+                return True
+
+        return False
+
     # Step Operations
 
     async def create_step(self, step: StepExecution) -> None:

pyworkflow/storage/sqlite.py

@@ -18,6 +18,7 @@ import aiosqlite
 
 from pyworkflow.engine.events import Event, EventType
 from pyworkflow.storage.base import StorageBackend
+from pyworkflow.storage.migrations import Migration, MigrationRegistry, MigrationRunner
 from pyworkflow.storage.schemas import (
     Hook,
     HookStatus,
@@ -31,6 +32,103 @@ from pyworkflow.storage.schemas import (
 )
 
 
+class SQLiteMigrationRunner(MigrationRunner):
+    """SQLite-specific migration runner."""
+
+    def __init__(self, db: aiosqlite.Connection, registry: MigrationRegistry | None = None) -> None:
+        super().__init__(registry)
+        self._db = db
+
+    async def ensure_schema_versions_table(self) -> None:
+        """Create schema_versions table if it doesn't exist."""
+        await self._db.execute("""
+            CREATE TABLE IF NOT EXISTS schema_versions (
+                version INTEGER PRIMARY KEY,
+                applied_at TIMESTAMP NOT NULL,
+                description TEXT
+            )
+        """)
+        await self._db.commit()
+
+    async def get_current_version(self) -> int:
+        """Get the highest applied migration version."""
+        async with self._db.execute(
+            "SELECT COALESCE(MAX(version), 0) as version FROM schema_versions"
+        ) as cursor:
+            row = await cursor.fetchone()
+            return row[0] if row else 0
+
+    async def detect_existing_schema(self) -> bool:
+        """Check if the events table exists (pre-versioning database)."""
+        async with self._db.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='events'"
+        ) as cursor:
+            row = await cursor.fetchone()
+            return row is not None
+
+    async def record_baseline_version(self, version: int, description: str) -> None:
+        """Record a baseline version without running migrations."""
+        await self._db.execute(
+            """
+            INSERT OR IGNORE INTO schema_versions (version, applied_at, description)
+            VALUES (?, ?, ?)
+            """,
+            (version, datetime.now(UTC).isoformat(), description),
+        )
+        await self._db.commit()
+
+    async def apply_migration(self, migration: Migration) -> None:
+        """Apply a migration with SQLite-specific handling."""
+        if migration.version == 2:
+            # V2: Add step_id column to events table
+            # First check if events table exists (fresh databases won't have it yet)
+            async with self._db.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='events'"
+            ) as cursor:
+                table_exists = await cursor.fetchone() is not None
+
+            if table_exists:
+                # SQLite doesn't have IF NOT EXISTS for columns, so check first
+                async with self._db.execute("PRAGMA table_info(events)") as cursor:
+                    columns = await cursor.fetchall()
+                    column_names = [col[1] for col in columns]
+
+                if "step_id" not in column_names:
+                    await self._db.execute("ALTER TABLE events ADD COLUMN step_id TEXT")
+
+                # Create index for optimized has_event() queries
+                await self._db.execute("""
+                    CREATE INDEX IF NOT EXISTS idx_events_run_id_step_id_type
+                    ON events(run_id, step_id, type)
+                """)
+
+                # Backfill step_id from JSON data using json_extract
+                await self._db.execute("""
+                    UPDATE events
+                    SET step_id = json_extract(data, '$.step_id')
+                    WHERE step_id IS NULL
+                      AND json_extract(data, '$.step_id') IS NOT NULL
+                """)
+
+                await self._db.commit()
+            # If table doesn't exist, schema will be created with step_id column
+        elif migration.up_func:
+            await migration.up_func(self._db)
+        elif migration.up_sql and migration.up_sql != "SELECT 1":
+            await self._db.execute(migration.up_sql)
+            await self._db.commit()
+
+        # Record the migration
+        await self._db.execute(
+            """
+            INSERT INTO schema_versions (version, applied_at, description)
+            VALUES (?, ?, ?)
+            """,
+            (migration.version, datetime.now(UTC).isoformat(), migration.description),
+        )
+        await self._db.commit()
+
+
 class SQLiteStorageBackend(StorageBackend):
     """
     SQLite storage backend using aiosqlite for async operations.
@@ -72,7 +170,7 @@ class SQLiteStorageBackend(StorageBackend):
             self._initialized = False
 
     async def _initialize_schema(self) -> None:
-        """Create database tables if they don't exist."""
+        """Create database tables if they don't exist and run migrations."""
         if not self._db:
             await self.connect()
 
@@ -80,6 +178,10 @@ class SQLiteStorageBackend(StorageBackend):
         assert self._db is not None
         db = self._db
 
+        # Run migrations first (handles schema versioning)
+        runner = SQLiteMigrationRunner(db)
+        await runner.run_migrations()
+
         # Workflow runs table
         await db.execute("""
             CREATE TABLE IF NOT EXISTS workflow_runs (
@@ -123,7 +225,7 @@ class SQLiteStorageBackend(StorageBackend):
             "CREATE INDEX IF NOT EXISTS idx_runs_parent_run_id ON workflow_runs(parent_run_id)"
         )
 
-        # Events table
+        # Events table (includes step_id column added in V2 migration)
         await db.execute("""
             CREATE TABLE IF NOT EXISTS events (
                 event_id TEXT PRIMARY KEY,
@@ -132,6 +234,7 @@ class SQLiteStorageBackend(StorageBackend):
                 type TEXT NOT NULL,
                 timestamp TIMESTAMP NOT NULL,
                 data TEXT NOT NULL DEFAULT '{}',
+                step_id TEXT,
                 FOREIGN KEY (run_id) REFERENCES workflow_runs(run_id) ON DELETE CASCADE
             )
         """)
@@ -140,7 +243,14 @@ class SQLiteStorageBackend(StorageBackend):
         await db.execute(
             "CREATE INDEX IF NOT EXISTS idx_events_run_id_sequence ON events(run_id, sequence)"
         )
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_events_type ON events(type)")
+        # Composite index for get_events() with type filter
+        await db.execute(
+            "CREATE INDEX IF NOT EXISTS idx_events_run_id_type ON events(run_id, type)"
+        )
+        # Optimized index for has_event() with step_id filter (V2 migration)
+        await db.execute(
+            "CREATE INDEX IF NOT EXISTS idx_events_run_id_step_id_type ON events(run_id, step_id, type)"
+        )
 
         # Steps table
         await db.execute("""
@@ -447,6 +557,9 @@ class SQLiteStorageBackend(StorageBackend):
         """Record an event to the append-only event log."""
         db = self._ensure_connected()
 
+        # Extract step_id from event data for indexed column
+        step_id = event.data.get("step_id") if event.data else None
+
         # Get next sequence number
         async with db.execute(
             "SELECT COALESCE(MAX(sequence), -1) + 1 FROM events WHERE run_id = ?",
@@ -457,8 +570,8 @@ class SQLiteStorageBackend(StorageBackend):
 
         await db.execute(
             """
-            INSERT INTO events (event_id, run_id, sequence, type, timestamp, data)
-            VALUES (?, ?, ?, ?, ?, ?)
+            INSERT INTO events (event_id, run_id, sequence, type, timestamp, data, step_id)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
             """,
             (
                 event.event_id,
@@ -467,6 +580,7 @@ class SQLiteStorageBackend(StorageBackend):
                 event.type.value,
                 event.timestamp.isoformat(),
                 json.dumps(event.data),
+                step_id,
             ),
         )
         await db.commit()
@@ -529,6 +643,56 @@ class SQLiteStorageBackend(StorageBackend):
 
         return self._row_to_event(row)
 
+    async def has_event(
+        self,
+        run_id: str,
+        event_type: str,
+        **filters: str,
+    ) -> bool:
+        """
+        Check if an event exists using optimized indexed queries.
+
+        When step_id is the only filter, uses a direct indexed query (O(1) lookup).
+        For other filters, falls back to loading events of the type and filtering in Python.
+
+        Args:
+            run_id: Workflow run identifier
+            event_type: Event type to check for
+            **filters: Additional filters for event data fields
+
+        Returns:
+            True if a matching event exists, False otherwise
+        """
+        db = self._ensure_connected()
+
+        # Optimized path: if only filtering by step_id, use indexed column directly
+        if filters.keys() == {"step_id"}:
+            step_id = str(filters["step_id"])
+            async with db.execute(
+                """
+                SELECT 1 FROM events
+                WHERE run_id = ? AND type = ? AND step_id = ?
+                LIMIT 1
+                """,
+                (run_id, event_type, step_id),
+            ) as cursor:
+                row = await cursor.fetchone()
+            return row is not None
+
+        # Fallback: load events of type and filter in Python
+        events = await self.get_events(run_id, event_types=[event_type])
+
+        for event in events:
+            match = True
+            for key, value in filters.items():
+                if str(event.data.get(key)) != str(value):
+                    match = False
+                    break
+            if match:
+                return True
+
+        return False
+
     # Step Operations
 
     async def create_step(self, step: StepExecution) -> None:
@@ -1119,6 +1283,7 @@ class SQLiteStorageBackend(StorageBackend):
 
     def _row_to_event(self, row: Any) -> Event:
         """Convert database row to Event object."""
+        # Column order: event_id[0], run_id[1], sequence[2], type[3], timestamp[4], data[5], step_id[6]
         return Event(
             event_id=row[0],
             run_id=row[1],
@@ -1126,6 +1291,7 @@ class SQLiteStorageBackend(StorageBackend):
             type=EventType(row[3]),
             timestamp=datetime.fromisoformat(row[4]),
             data=json.loads(row[5]) if row[5] else {},
+            # step_id is in row[6] but not used in Event object (it's denormalized for query optimization)
         )
 
     def _row_to_step_execution(self, row: Any) -> StepExecution:

{pyworkflow_engine-0.1.22.dist-info → pyworkflow_engine-0.1.23.dist-info}/METADATA

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

{pyworkflow_engine-0.1.22.dist-info → pyworkflow_engine-0.1.23.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyworkflow/__init__.py,sha256=HigyYErtUxyfrsBOPEUvegnsLnqnwfrBm87EEzfYtOI,6281
+pyworkflow/__init__.py,sha256=g24ALTMah13y4dLj3Doyb-0wsQnTdu3_9wCXFsshdW4,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,11 +6,11 @@ pyworkflow/aws/context.py,sha256=C_wBr_YRUYT4IHyaAGPdiqRPNbH8mDLkoMpVtQVIg28,822
 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=QXpPXVVuwJv3ToylT0pyz9SgmwjC9hW-9WaIO4wH5OQ,14349
+pyworkflow/celery/app.py,sha256=MXmD5N8DCrX9YpdccOWPy2ob7k4vg9r0ix1kDgDuR3w,15753
 pyworkflow/celery/loop.py,sha256=mu8cIfMJYgHAoGCN_DdDoNoXK3QHzHpLmrPCyFDQYIY,3016
 pyworkflow/celery/scheduler.py,sha256=Ms4rqRpdpMiLM8l4y3DK-Divunj9afYuUaGGoNQe7P4,11288
 pyworkflow/celery/singleton.py,sha256=9gdVHzqFjShZ9OJOJlJNABUg9oqnl6ITGROtomcOtsg,16070
-pyworkflow/celery/tasks.py,sha256=0doKC7JxGlU4QFShohQn9NRgiOybfLrBm6j81C8m3dc,88482
+pyworkflow/celery/tasks.py,sha256=FiZFBTHUQz16AWYmsHUGmTIxXQ5zNewyFWUGRizS4b8,88813
 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
@@ -73,22 +73,24 @@ pyworkflow/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 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=4rPBrmRpxkZFNjmxOl7e5B8hVJ6kRM3XPCH_qgA1hFI,17404
-pyworkflow/storage/cassandra.py,sha256=wevLXyx8WHya1QafnY5YUurvveyM2F2EEilD_G6RM_U,62560
+pyworkflow/storage/base.py,sha256=CTvZwy8cHMdbOV3ZYVlbsx0fBNZN9cusbbh3oqGmrao,18598
+pyworkflow/storage/cassandra.py,sha256=3VDwiM9zaxKNwp5vdX1FdqpwFm0AZfTWtVDTmIKBA7Q,63538
 pyworkflow/storage/config.py,sha256=45UMPxRoqgK4ZwE7HIK9ctxE_eoK3eAE_1tRhn3Psd4,12410
-pyworkflow/storage/dynamodb.py,sha256=_X2Ijj3lEaOYfuYSdf6y4uhZBXHMovZOUS9XFuCz3Uk,55523
-pyworkflow/storage/file.py,sha256=7CiEQ6lhRXAyUr_tEG_G4OxqllcHaGu0353v_9de-DU,31095
-pyworkflow/storage/memory.py,sha256=YiA3n0BX7UOcgOkXxCtm7U3GTC5SlzUCrHIANSwoI7c,21040
-pyworkflow/storage/mysql.py,sha256=bQyyu1-SqjTaGcV4woh3sr2bz_TrftCvoTXuVOQZq1A,44432
-pyworkflow/storage/postgres.py,sha256=ZbPyT3-s7jCDLpTZe4CJYCtU1VQgldIcq4wl1hjFRAU,46113
+pyworkflow/storage/dynamodb.py,sha256=hER4rOc0GWh0-yk0YiFrxZkiHJ6DKEOpvZQ9GCEx8QQ,56501
+pyworkflow/storage/file.py,sha256=Ag4K5Rt-8YaENZLx-HnN77EAfNc37WqkymmaPlVJbYg,32665
+pyworkflow/storage/memory.py,sha256=HiuGU9jgzKwNGrF98YHdHYrzQTNUu96VyL5HVVeII7A,22179
+pyworkflow/storage/mysql.py,sha256=lS9dZHmtPL14cY1lrzDFilFKmsjMD_b0NnYJfiPDFKQ,52537
+pyworkflow/storage/postgres.py,sha256=Afjh1qQ9KL7Xb-tT3fVRGK1vJ_j46r-4Lym0XHhOkf8,53893
 pyworkflow/storage/schemas.py,sha256=o1ntTYNgQQ5YVuXtPCShtENEsndVjdrXclWrkCgkitg,18002
-pyworkflow/storage/sqlite.py,sha256=h48FOGtsHHglIEe4hBkf_vR41pwumDDATGsz7-u3wQA,40987
+pyworkflow/storage/sqlite.py,sha256=EJ8n66WfhZnfFLKcNdUOoOCswdftttoH6T31spS78Qo,47667
+pyworkflow/storage/migrations/__init__.py,sha256=R8b-VoVzpYJ6A-Z5FDNbrbOO-2Nnt4NrcAS8Wo08VPo,425
+pyworkflow/storage/migrations/base.py,sha256=Thq38E8BDpC7EmBlwpfm727Zyz4TVmADQ1kEttWo0oY,9237
 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.22.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
-pyworkflow_engine-0.1.22.dist-info/METADATA,sha256=vulOQGFZqTd-TJ3fjgTY1JQBB942bJr97aw7bHs3jTA,19628
-pyworkflow_engine-0.1.22.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyworkflow_engine-0.1.22.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
-pyworkflow_engine-0.1.22.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
-pyworkflow_engine-0.1.22.dist-info/RECORD,,
+pyworkflow_engine-0.1.23.dist-info/licenses/LICENSE,sha256=Y49RCTZ5ayn_yzBcRxnyIFdcMCyuYm150aty_FIznfY,1080
+pyworkflow_engine-0.1.23.dist-info/METADATA,sha256=PrBwRu_9khJBesYc1p_cyXTNgHvM_uZU-XUyejvOjkk,19628
+pyworkflow_engine-0.1.23.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyworkflow_engine-0.1.23.dist-info/entry_points.txt,sha256=3IGAfuylnS39U0YX0pxnjrj54kB4iT_bNYrmsiDB-dE,51
+pyworkflow_engine-0.1.23.dist-info/top_level.txt,sha256=FLTv9pQmLDBXrQdLOhTMIS3njFibliMsQEfumqmdzBE,11
+pyworkflow_engine-0.1.23.dist-info/RECORD,,