edda-framework 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

edda/storage/sqlalchemy_storage.py

@@ -88,6 +88,7 @@ class WorkflowInstance(Base):
     workflow_name: Mapped[str] = mapped_column(String(255))
     source_hash: Mapped[str] = mapped_column(String(64))
     owner_service: Mapped[str] = mapped_column(String(255))
+    framework: Mapped[str] = mapped_column(String(50), server_default=text("'python'"))
     status: Mapped[str] = mapped_column(String(50), server_default=text("'running'"))
     current_activity_id: Mapped[str | None] = mapped_column(String(255), nullable=True)
     continued_from: Mapped[str | None] = mapped_column(
@@ -121,6 +122,7 @@ class WorkflowInstance(Base):
         Index("idx_instances_status", "status"),
         Index("idx_instances_workflow", "workflow_name"),
         Index("idx_instances_owner", "owner_service"),
+        Index("idx_instances_framework", "framework"),
         Index("idx_instances_locked", "locked_by", "locked_at"),
         Index("idx_instances_lock_expires", "lock_expires_at"),
         Index("idx_instances_updated", "updated_at"),
@@ -516,6 +518,7 @@ class SQLAlchemyStorage:
         self,
         engine: AsyncEngine,
         notify_listener: Any | None = None,
+        migrations_dir: str | None = None,
     ):
         """
         Initialize SQLAlchemy storage.
@@ -525,9 +528,12 @@ class SQLAlchemyStorage:
             notify_listener: Optional notify listener for PostgreSQL LISTEN/NOTIFY.
                             If provided and PostgreSQL is used, NOTIFY messages
                             will be sent after key operations.
+            migrations_dir: Optional path to migrations directory. If None,
+                           auto-detects from package or schema/ submodule.
         """
         self.engine = engine
         self._notify_listener = notify_listener
+        self._migrations_dir = migrations_dir
 
     @property
     def _is_postgresql(self) -> bool:
@@ -551,20 +557,21 @@ class SQLAlchemyStorage:
         self._notify_listener = listener
 
     async def initialize(self) -> None:
-        """Initialize database connection and create tables.
+        """Initialize database connection and apply migrations.
 
-        This method creates all tables if they don't exist, and then performs
-        automatic schema migration to add any missing columns and update CHECK
-        constraints. This ensures compatibility when upgrading Edda versions.
+        This method automatically applies dbmate migration files to create
+        tables and update schema. It tracks applied migrations in the
+        schema_migrations table (compatible with dbmate CLI).
         """
-        # Create all tables and indexes
-        async with self.engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
+        from pathlib import Path
+
+        from .migrations import apply_dbmate_migrations
 
-        # Auto-migrate schema (add missing columns)
-        await self._auto_migrate_schema()
+        # Apply dbmate migrations
+        migrations_dir = Path(self._migrations_dir) if self._migrations_dir else None
+        await apply_dbmate_migrations(self.engine, migrations_dir)
 
-        # Auto-migrate CHECK constraints
+        # Auto-migrate CHECK constraints (for existing tables)
         await self._auto_migrate_check_constraints()
 
         # Initialize schema version
@@ -1227,6 +1234,7 @@ class SQLAlchemyStorage:
                 workflow_name=workflow_name,
                 source_hash=source_hash,
                 owner_service=owner_service,
+                framework="python",
                 input_data=json.dumps(input_data),
                 lock_timeout_seconds=lock_timeout_seconds,
                 continued_from=continued_from,
@@ -1332,6 +1340,7 @@ class SQLAlchemyStorage:
                         WorkflowInstance.source_hash == WorkflowDefinition.source_hash,
                     ),
                 )
+                .where(WorkflowInstance.framework == "python")
                 .order_by(
                     WorkflowInstance.started_at.desc(),
                     WorkflowInstance.instance_id.desc(),
@@ -1700,6 +1709,7 @@ class SQLAlchemyStorage:
                         WorkflowInstance.lock_expires_at.isnot(None),
                         self._make_datetime_comparable(WorkflowInstance.lock_expires_at)
                         < self._get_current_time_expr(),
+                        WorkflowInstance.framework == "python",
                     )
                 )
             )
@@ -1752,10 +1762,9 @@ class SQLAlchemyStorage:
         """
         Try to acquire a system-level lock for coordinating background tasks.
 
-        Uses INSERT ON CONFLICT pattern to handle race conditions:
-        1. Try to INSERT new lock record
-        2. If exists, check if expired or unlocked
-        3. If available, acquire lock; otherwise return False
+        Uses atomic UPDATE pattern to avoid race conditions:
+        1. Ensure row exists (INSERT OR IGNORE / ON CONFLICT DO NOTHING)
+        2. Atomic UPDATE with WHERE condition (rowcount determines success)
 
         Note: ALWAYS uses separate session (not external session).
         """
@@ -1764,51 +1773,78 @@ class SQLAlchemyStorage:
             current_time = datetime.now(UTC)
             lock_expires_at = current_time + timedelta(seconds=timeout_seconds)
 
-            # Try to get existing lock
-            result = await session.execute(
-                select(SystemLock).where(SystemLock.lock_name == lock_name)
-            )
-            lock = result.scalar_one_or_none()
+            # Get dialect name
+            dialect_name = self.engine.dialect.name
+
+            # 1. Ensure row exists (idempotent INSERT)
+            if dialect_name == "sqlite":
+                from sqlalchemy.dialects.sqlite import insert as sqlite_insert
+
+                stmt: Any = (
+                    sqlite_insert(SystemLock)
+                    .values(
+                        lock_name=lock_name,
+                        locked_by=None,
+                        locked_at=None,
+                        lock_expires_at=None,
+                    )
+                    .on_conflict_do_nothing(index_elements=["lock_name"])
+                )
+            elif dialect_name == "postgresql":
+                from sqlalchemy.dialects.postgresql import insert as pg_insert
 
-            if lock is None:
-                # No lock exists - create new one
-                lock = SystemLock(
-                    lock_name=lock_name,
+                stmt = (
+                    pg_insert(SystemLock)
+                    .values(
+                        lock_name=lock_name,
+                        locked_by=None,
+                        locked_at=None,
+                        lock_expires_at=None,
+                    )
+                    .on_conflict_do_nothing(index_elements=["lock_name"])
+                )
+            else:  # mysql
+                from sqlalchemy.dialects.mysql import insert as mysql_insert
+
+                stmt = (
+                    mysql_insert(SystemLock)
+                    .values(
+                        lock_name=lock_name,
+                        locked_by=None,
+                        locked_at=None,
+                        lock_expires_at=None,
+                    )
+                    .on_duplicate_key_update(lock_name=lock_name)
+                )  # No-op update
+
+            await session.execute(stmt)
+            await session.commit()
+
+            # 2. Atomic UPDATE to acquire lock (rowcount == 1 means success)
+            # Use SQL-side datetime comparison for cross-DB compatibility
+            current_time_expr = self._get_current_time_expr()
+            result = await session.execute(
+                update(SystemLock)
+                .where(
+                    and_(
+                        SystemLock.lock_name == lock_name,
+                        or_(
+                            SystemLock.locked_by == None,  # noqa: E711
+                            SystemLock.locked_by == worker_id,  # Allow renewal by same worker
+                            self._make_datetime_comparable(SystemLock.lock_expires_at)
+                            <= current_time_expr,
+                        ),
+                    )
+                )
+                .values(
                     locked_by=worker_id,
                     locked_at=current_time,
                     lock_expires_at=lock_expires_at,
                 )
-                session.add(lock)
-                await session.commit()
-                return True
-
-            # Lock exists - check if available
-            if lock.locked_by is None:
-                # Unlocked - acquire
-                lock.locked_by = worker_id
-                lock.locked_at = current_time
-                lock.lock_expires_at = lock_expires_at
-                await session.commit()
-                return True
-
-            # Check if expired (use SQL-side comparison for cross-DB compatibility)
-            if lock.lock_expires_at is not None:
-                # Handle timezone-naive datetime from SQLite
-                lock_expires = (
-                    lock.lock_expires_at.replace(tzinfo=UTC)
-                    if lock.lock_expires_at.tzinfo is None
-                    else lock.lock_expires_at
-                )
-                if lock_expires <= current_time:
-                    # Expired - acquire
-                    lock.locked_by = worker_id
-                    lock.locked_at = current_time
-                    lock.lock_expires_at = lock_expires_at
-                    await session.commit()
-                    return True
+            )
+            await session.commit()
 
-            # Already locked by another worker
-            return False
+            return bool(result.rowcount == 1)  # type: ignore[attr-defined]
 
     async def release_system_lock(self, lock_name: str, worker_id: str) -> None:
         """
@@ -2033,7 +2069,7 @@ class SQLAlchemyStorage:
             result = await session.execute(
                 select(WorkflowCompensation)
                 .where(WorkflowCompensation.instance_id == instance_id)
-                .order_by(WorkflowCompensation.created_at.desc())
+                .order_by(WorkflowCompensation.created_at.desc(), WorkflowCompensation.id.desc())
             )
             rows = result.scalars().all()
 
@@ -2178,6 +2214,7 @@ class SQLAlchemyStorage:
                         self._make_datetime_comparable(WorkflowTimerSubscription.expires_at)
                         <= self._get_current_time_expr(),
                         WorkflowInstance.status == "waiting_for_timer",
+                        WorkflowInstance.framework == "python",
                     )
                 )
             )
@@ -2252,7 +2289,7 @@ class SQLAlchemyStorage:
 
         # Send NOTIFY for new outbox event
         await self._send_notify(
-            "edda_outbox_pending",
+            "workflow_outbox_pending",
             {"evt_id": event_id, "evt_type": event_type},
         )
 
@@ -2764,6 +2801,7 @@ class SQLAlchemyStorage:
                         ChannelSubscription.activity_id.isnot(None),  # Only waiting subscriptions
                         self._make_datetime_comparable(ChannelSubscription.timeout_at)
                         <= self._get_current_time_expr(),
+                        WorkflowInstance.framework == "python",
                     )
                 )
             )
@@ -2902,6 +2940,7 @@ class SQLAlchemyStorage:
                 and_(
                     WorkflowInstance.status == "running",
                     WorkflowInstance.locked_by.is_(None),
+                    WorkflowInstance.framework == "python",
                 )
             )
             if limit is not None:
@@ -3002,12 +3041,9 @@ class SQLAlchemyStorage:
             session.add(msg)
             await self._commit_if_not_in_transaction(session)
 
-        # Send NOTIFY for message published (channel-specific)
-        import hashlib
-
-        channel_hash = hashlib.sha256(channel.encode()).hexdigest()[:16]
+        # Send NOTIFY for message published (unified channel name)
         await self._send_notify(
-            f"edda_msg_{channel_hash}",
+            "workflow_channel_message",
             {"ch": channel, "msg_id": message_id},
         )
 
@@ -3571,7 +3607,7 @@ class SQLAlchemyStorage:
 
                 # Send NOTIFY for workflow resumable
                 await self._send_notify(
-                    "edda_workflow_resumable",
+                    "workflow_resumable",
                     {"wf_id": instance_id, "wf_name": workflow_name},
                 )
 

edda/viewer_ui/app.py

@@ -309,6 +309,10 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
                     all_workflows = service.get_all_workflows()
                     workflow_names = list(all_workflows.keys())
 
+                    workflow_select: Any = None
+                    params_container: Any = None
+                    param_fields: dict[str, Any] = {}
+
                     if not workflow_names:
                         ui.label("No workflows registered").classes("text-red-500")
                         ui.button("Close", on_click=start_dialog.close)
@@ -323,9 +327,6 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
                         # Container for dynamic parameter fields
                         params_container = ui.column().classes("w-full mb-4")
 
-                        # Store input field references
-                        param_fields: dict[str, Any] = {}
-
                     # Factory functions for creating field managers with proper closures
                     # These must be defined outside the loop to avoid closure issues
 
@@ -778,6 +779,8 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
 
                     def update_parameter_fields() -> None:
                         """Update parameter input fields based on selected workflow."""
+                        if workflow_select is None or params_container is None:
+                            return
                         selected_workflow = workflow_select.value
                         if not selected_workflow:
                             return
@@ -1106,13 +1109,17 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
                     update_parameter_fields()
 
                     # Update fields when workflow selection changes
-                    workflow_select.on_value_change(lambda _: update_parameter_fields())
+                    if workflow_select is not None:
+                        workflow_select.on_value_change(lambda _: update_parameter_fields())
 
                     # Action buttons
                     with ui.row().classes("w-full gap-2"):
 
                         async def handle_start() -> None:
                             """Handle workflow start."""
+                            if workflow_select is None:
+                                ui.notify("No workflows available", type="negative")
+                                return
                             try:
                                 selected_workflow = workflow_select.value
                                 if not selected_workflow:

{edda_framework-0.11.0.dist-info → edda_framework-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.11.0
+Version: 0.13.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -286,6 +286,46 @@ pip install "git+https://github.com/i2y/edda.git[postgresql,viewer]"
 
 > **Tip**: For PostgreSQL, install the `postgres-notify` extra for near-instant event delivery using LISTEN/NOTIFY instead of polling.
 
+### Database Schema Migration
+
+**Automatic Migration (Default)**
+
+Edda automatically applies database migrations at startup. No manual commands needed:
+
+```python
+from edda import EddaApp
+
+# Migrations are applied automatically
+app = EddaApp(db_url="postgresql://user:pass@localhost/dbname")
+```
+
+This is safe in multi-worker environments - Edda handles concurrent startup gracefully.
+
+**Manual Migration with dbmate (Optional)**
+
+For explicit schema control, you can disable auto-migration and use [dbmate](https://github.com/amacneil/dbmate):
+
+```python
+# Disable auto-migration
+app = EddaApp(
+    db_url="postgresql://...",
+    auto_migrate=False  # Use dbmate-managed schema
+)
+```
+
+```bash
+# Install dbmate
+brew install dbmate  # macOS
+
+# Add schema submodule
+git submodule add https://github.com/durax-io/schema.git schema
+
+# Run migration manually
+DATABASE_URL="postgresql://user:pass@localhost/dbname" dbmate -d ./schema/db/migrations/postgresql up
+```
+
+> **Note**: Edda's auto-migration uses the same SQL files as dbmate, maintaining full compatibility.
+
 ### Development Installation
 
 If you want to contribute to Edda or modify the framework itself:
@@ -293,7 +333,7 @@ If you want to contribute to Edda or modify the framework itself:
 ```bash
 # Clone repository
 git clone https://github.com/i2y/edda.git
-cd kairo
+cd edda
 uv sync --all-extras
 ```
 
@@ -333,7 +373,7 @@ async def user_signup(ctx: WorkflowContext, email: str):
     return {"status": "completed"}
 ```
 
-**Activity IDs**: Activities are automatically identified with IDs like `"send_email:1"` for deterministic replay. Manual IDs are only needed for concurrent execution (e.g., `asyncio.gather`). See [MIGRATION_GUIDE_ACTIVITY_ID.md](MIGRATION_GUIDE_ACTIVITY_ID.md) for details.
+**Activity IDs**: Activities are automatically identified with IDs like `"send_email:1"` for deterministic replay. Manual IDs are only needed for concurrent execution (e.g., `asyncio.gather`).
 
 ### Durable Execution
 

{edda_framework-0.11.0.dist-info → edda_framework-0.13.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
 edda/__init__.py,sha256=hGC6WR2R36M8LWC97F-0Rw4Ln0QUUT_1xC-7acOy_Fk,2237
 edda/activity.py,sha256=nRm9eBrr0lFe4ZRQ2whyZ6mo5xd171ITIVhqytUhOpw,21025
-edda/app.py,sha256=hoxDKp6q5qHl_dNLMkLxKhuibUC6D8FtuiWsIZkzwhA,61546
-edda/channels.py,sha256=Budi0FyxalmcAMwj50mX3WzRce5OuLKXGws0Hp_snfw,34745
+edda/app.py,sha256=ITTc7x5S4ykCP3KPZXKxuNczXkPtbn04ZQaxcem46Hw,68406
+edda/channels.py,sha256=CosFoB9HVHBKRmhU_t6qoCV3l6egAGt3sqpakfgZLKc,36596
 edda/compensation.py,sha256=iKLlnTxiF1YSatmYQW84EkPB1yMKUEZBtgjuGnghLtY,11824
-edda/context.py,sha256=pPn98-G5HgaOGDRzEhma58TzBulwsiTvmNEMLIu0XwI,21330
+edda/context.py,sha256=Qqm_nUC5NNnOfHAb7taqKqZVIc0GoRWUrjZ4L9_-q70,22128
 edda/exceptions.py,sha256=-ntBLGpVQgPFG5N1o8m_7weejAYkNrUdxTkOP38vsHk,1766
 edda/hooks.py,sha256=HUZ6FTM__DZjwuomDfTDEroQ3mugEPuJHcGm7CTQNvg,8193
 edda/locking.py,sha256=NAFJmw-JaSVsXn4Y4czJyv_s9bWG8cdrzDBWIEag5X8,13661
 edda/pydantic_utils.py,sha256=dGVPNrrttDeq1k233PopCtjORYjZitsgASPfPnO6R10,9056
-edda/replay.py,sha256=_poGUfvsDJP8GiflAw6aCZzxMKJpo99z__JVdGHb75I,42567
+edda/replay.py,sha256=IQGByw9mlTpRulyUgsHJSPsZUULmM2YqFcm2WeB4jtw,43227
 edda/retry.py,sha256=t4_E1skrhotA1XWHTLbKi-DOgCMasOUnhI9OT-O_eCE,6843
 edda/workflow.py,sha256=hfBZM0JrtK0IkvZSrva0VmYVyvKCdiJ5FWFmIVENfrM,8807
 edda/wsgi.py,sha256=1pGE5fhHpcsYnDR8S3NEFKWUs5P0JK4roTAzX9BsIj0,2391
@@ -24,27 +24,31 @@ edda/integrations/mirascope/types.py,sha256=vgEAu8EFTLSd92XSAxtZpMoe5gv93fe4Rm0D
 edda/integrations/opentelemetry/__init__.py,sha256=x1_PyyygGDW-rxQTwoIrGzyjKErXHOOKdquFAMlCOAo,906
 edda/integrations/opentelemetry/hooks.py,sha256=rCb6K_gJJMxjQ-UoJnbIOWsafapipzu7w-YPROZKxDA,21330
 edda/outbox/__init__.py,sha256=azXG1rtheJEjOyoWmMsBeR2jp8Bz02R3wDEd5tQnaWA,424
-edda/outbox/relayer.py,sha256=_yOZVpjj862lzMtEK47RMdVdbxXmL8v-FXppZWdy4Ag,10444
+edda/outbox/relayer.py,sha256=b14BaFnBODg4bz0ft8UZxqORlTQON5SHu4wrfYs3Lx4,11467
 edda/outbox/transactional.py,sha256=LFfUjunqRlGibaINi-efGXFFivWGO7v3mhqrqyGW6Nw,3808
 edda/serialization/__init__.py,sha256=hnOVJN-mJNIsSa_XH9jwhIydOsWvIfCaFaSd37HUplg,216
 edda/serialization/base.py,sha256=xJy2CY9gdJDCF0tmCor8NomL2Lr_w7cveVvxccuc-tA,1998
 edda/serialization/json.py,sha256=Dq96V4n1yozexjCPd_CL6Iuvh1u3jJhef6sTcNxXZeA,2842
 edda/storage/__init__.py,sha256=NjvAzYV3SknACrC16ZQOA-xCKOj1-s3rBIWOS1ZGCaM,407
-edda/storage/models.py,sha256=vUwjiAOvp9uFNQgLK57kEGo7uzXplDZikOfnlOyed2M,12146
+edda/storage/migrations.py,sha256=KrceouVODct9WWDBhmjAW0IYptDWd2mqJmhrHnee59M,13704
+edda/storage/models.py,sha256=axXGJ-Orwcd_AsEUwIyFfDyg3NQxMcOQ2mrTzXkNv3g,12284
 edda/storage/notify_base.py,sha256=gUb-ypG1Bo0c-KrleYmC7eKtdwQNUeqGS5k7UILlSsQ,5055
-edda/storage/pg_notify.py,sha256=to5rDIQbiqqkNNVMODye_KvY4EDqRSUQblTeoeDZv8w,11850
+edda/storage/pg_notify.py,sha256=myzJ9xX86uiro9aaiA1SW1sN3E-zYafn7_lpeAy1jOg,11830
 edda/storage/protocol.py,sha256=vdB5GvBen8lgUA0qEfBXfQTLbVfGKeBTQuEwSUqLZtI,39463
-edda/storage/sqlalchemy_storage.py,sha256=IAc8SYHM2xoJEIVDG05_mkguWQGB3wIAALsc0QI8EcE,144484
+edda/storage/sqlalchemy_storage.py,sha256=HREK7fHmq3DGx6w4jA03_NrQu9HbyMomyIawMuOQLYQ,146246
 edda/viewer_ui/__init__.py,sha256=N1-T33SXadOXcBsDSgJJ9Iqz4y4verJngWryQu70c5c,517
-edda/viewer_ui/app.py,sha256=K3c5sMeJz_AE9gh5QftxwvfDthLeJi1i2CDkP9gb4Ig,96695
+edda/viewer_ui/app.py,sha256=xZdIIGX5D2efNWQSVpPdldxLukHHpJD7JiAa_YKG5Uw,97084
 edda/viewer_ui/components.py,sha256=A0IxLwgj_Lu51O57OfzOwME8jzoJtKegEVvSnWc7uPo,45174
 edda/viewer_ui/data_service.py,sha256=KOqnWr-Y8seH_dkJH_ejHRfxQqn7aY8Ni5C54tx2Z-E,36621
 edda/viewer_ui/theme.py,sha256=mrXoXLRzgSnvE2a58LuMcPJkhlvHEDMWVa8Smqtk4l0,8118
 edda/visualizer/__init__.py,sha256=DOpDstNhR0VcXAs_eMKxaL30p_0u4PKZ4o2ndnYhiRo,343
 edda/visualizer/ast_analyzer.py,sha256=plmx7C9X_X35xLY80jxOL3ljg3afXxBePRZubqUIkxY,13663
 edda/visualizer/mermaid_generator.py,sha256=XWa2egoOTNDfJEjPcwoxwQmblUqXf7YInWFjFRI1QGo,12457
-edda_framework-0.11.0.dist-info/METADATA,sha256=AkgFtGUJNfhOoHXzti_R7fLli1q45Bg5xO6TfpjvsO8,36587
-edda_framework-0.11.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-edda_framework-0.11.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.11.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.11.0.dist-info/RECORD,,
+edda/migrations/mysql/20251217000000_initial_schema.sql,sha256=LpINasESRhadOeqABwDk4JZ0OZ4_zQw_opnhIR4Xe9U,12367
+edda/migrations/postgresql/20251217000000_initial_schema.sql,sha256=hCaGMWeptpzpnsjfNKVsMYuwPRe__fK9E0VZpClAumQ,11732
+edda/migrations/sqlite/20251217000000_initial_schema.sql,sha256=Wq9gCnQ0K9SOt0PY_8f1MG4va8rLVWIIcf2lnRzSK5g,11906
+edda_framework-0.13.0.dist-info/METADATA,sha256=K-ar-0liixJ38d34eDvPGYPyWxUSKjgsQ_xwZPCbZ2A,37567
+edda_framework-0.13.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+edda_framework-0.13.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.13.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.13.0.dist-info/RECORD,,