edda-framework 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

edda/storage/sqlalchemy_storage.py

@@ -8,6 +8,7 @@ and transactional outbox pattern.
 
 import json
 import logging
+import re
 from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 from contextvars import ContextVar
@@ -511,14 +512,43 @@ class SQLAlchemyStorage:
     - Automatic transaction management via @activity decorator
     """
 
-    def __init__(self, engine: AsyncEngine):
+    def __init__(
+        self,
+        engine: AsyncEngine,
+        notify_listener: Any | None = None,
+    ):
         """
         Initialize SQLAlchemy storage.
 
         Args:
             engine: SQLAlchemy AsyncEngine instance
+            notify_listener: Optional notify listener for PostgreSQL LISTEN/NOTIFY.
+                            If provided and PostgreSQL is used, NOTIFY messages
+                            will be sent after key operations.
         """
         self.engine = engine
+        self._notify_listener = notify_listener
+
+    @property
+    def _is_postgresql(self) -> bool:
+        """Check if the database is PostgreSQL."""
+        return self.engine.dialect.name == "postgresql"
+
+    @property
+    def _notify_enabled(self) -> bool:
+        """Check if NOTIFY is enabled (PostgreSQL with listener)."""
+        return self._is_postgresql and self._notify_listener is not None
+
+    def set_notify_listener(self, listener: Any) -> None:
+        """Set the notify listener after initialization.
+
+        This allows setting the listener after EddaApp creates the storage,
+        useful for dependency injection patterns.
+
+        Args:
+            listener: NotifyProtocol implementation (PostgresNotifyListener or NoopNotifyListener)
+        """
+        self._notify_listener = listener
 
     async def initialize(self) -> None:
         """Initialize database connection and create tables.
@@ -544,6 +574,39 @@ class SQLAlchemyStorage:
         """Close database connection."""
         await self.engine.dispose()
 
+    async def _send_notify(
+        self,
+        channel: str,
+        payload: dict[str, Any],
+    ) -> None:
+        """Send PostgreSQL NOTIFY message.
+
+        This method sends a notification on the specified channel with the given
+        payload. It's a no-op if NOTIFY is not enabled (non-PostgreSQL or no listener).
+
+        Args:
+            channel: PostgreSQL NOTIFY channel name (max 63 chars).
+            payload: Dictionary to serialize as JSON payload (max ~7500 bytes).
+        """
+        if not self._notify_enabled:
+            return
+
+        try:
+            import json as json_module
+
+            payload_str = json_module.dumps(payload, separators=(",", ":"))
+
+            # Use a separate connection for NOTIFY to avoid transaction issues
+            async with self.engine.connect() as conn:
+                await conn.execute(
+                    text("SELECT pg_notify(:channel, :payload)"),
+                    {"channel": channel, "payload": payload_str},
+                )
+                await conn.commit()
+        except Exception as e:
+            # Log but don't fail - polling will catch it as backup
+            logger.warning(f"Failed to send NOTIFY on channel {channel}: {e}")
+
     async def _initialize_schema_version(self) -> None:
         """Initialize schema version for a fresh database."""
         async with AsyncSession(self.engine) as session:
@@ -849,6 +912,60 @@ class SQLAlchemyStorage:
             # PostgreSQL/MySQL: column is already timezone-aware
             return column
 
+    def _validate_json_path(self, json_path: str) -> bool:
+        """
+        Validate JSON path to prevent SQL injection.
+
+        Args:
+            json_path: JSON path string (e.g., "order_id" or "customer.email")
+
+        Returns:
+            True if valid, False otherwise
+        """
+        # Only allow alphanumeric characters, dots, and underscores
+        # Must start with letter or underscore
+        return bool(re.match(r"^[a-zA-Z_][a-zA-Z0-9_.]*$", json_path))
+
+    def _build_json_extract_expr(self, column: Any, json_path: str) -> Any:
+        """
+        Build a database-agnostic JSON extraction expression.
+
+        Args:
+            column: SQLAlchemy column containing JSON text
+            json_path: Dot-notation path (e.g., "order_id" or "customer.email")
+
+        Returns:
+            SQLAlchemy expression that extracts the value at json_path
+
+        Raises:
+            ValueError: If json_path is invalid or dialect is unsupported
+        """
+        if not self._validate_json_path(json_path):
+            raise ValueError(f"Invalid JSON path: {json_path}")
+
+        full_path = f"$.{json_path}"
+        dialect = self.engine.dialect.name
+
+        if dialect == "sqlite":
+            # SQLite: json_extract(column, '$.key')
+            return func.json_extract(column, full_path)
+        elif dialect == "postgresql":
+            # PostgreSQL: For nested paths, use #>> operator with array path
+            # For simple paths, use ->> operator
+            # Since we're dealing with Text column, we need to cast first
+            if "." in json_path:
+                # Nested: (column)::json #>> '{customer,email}'
+                path_array = "{" + json_path.replace(".", ",") + "}"
+                return text(f"(input_data)::json #>> '{path_array}'")
+            else:
+                # Simple: (column)::json->>'key'
+                return text(f"(input_data)::json->>'{json_path}'")
+        elif dialect == "mysql":
+            # MySQL: JSON_UNQUOTE(JSON_EXTRACT(column, '$.key'))
+            return func.JSON_UNQUOTE(func.JSON_EXTRACT(column, full_path))
+        else:
+            raise ValueError(f"Unsupported database dialect: {dialect}")
+
     # -------------------------------------------------------------------------
     # Transaction Management Methods
     # -------------------------------------------------------------------------
@@ -1200,6 +1317,7 @@ class SQLAlchemyStorage:
         instance_id_filter: str | None = None,
         started_after: datetime | None = None,
         started_before: datetime | None = None,
+        input_filters: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """List workflow instances with cursor-based pagination and filtering."""
         session = self._get_session_for_operation()
@@ -1292,6 +1410,42 @@ class SQLAlchemyStorage:
                         started_before_comparable = started_before
                     stmt = stmt.where(started_at_comparable <= started_before_comparable)
 
+            # Apply input data filters (JSON field matching)
+            if input_filters:
+                for json_path, expected_value in input_filters.items():
+                    dialect = self.engine.dialect.name
+                    if dialect == "postgresql":
+                        # PostgreSQL: use text() for the entire condition
+                        if not self._validate_json_path(json_path):
+                            raise ValueError(f"Invalid JSON path: {json_path}")
+                        if "." in json_path:
+                            path_array = "{" + json_path.replace(".", ",") + "}"
+                            json_sql = f"(input_data)::json #>> '{path_array}'"
+                        else:
+                            json_sql = f"(input_data)::json->>'{json_path}'"
+                        if expected_value is None:
+                            stmt = stmt.where(text(f"({json_sql} IS NULL OR {json_sql} = 'null')"))
+                        else:
+                            # Escape single quotes in value
+                            safe_value = str(expected_value).replace("'", "''")
+                            stmt = stmt.where(text(f"{json_sql} = '{safe_value}'"))
+                    else:
+                        # SQLite and MySQL: use func-based approach
+                        json_expr = self._build_json_extract_expr(
+                            WorkflowInstance.input_data, json_path
+                        )
+                        if expected_value is None:
+                            stmt = stmt.where(or_(json_expr.is_(None), json_expr == "null"))
+                        elif isinstance(expected_value, bool):
+                            stmt = stmt.where(json_expr == str(expected_value).lower())
+                        elif isinstance(expected_value, (int, float)):
+                            if dialect == "sqlite":
+                                stmt = stmt.where(json_expr == expected_value)
+                            else:
+                                stmt = stmt.where(json_expr == str(expected_value))
+                        else:
+                            stmt = stmt.where(json_expr == str(expected_value))
+
             # Fetch limit+1 to determine if there are more pages
             stmt = stmt.limit(limit + 1)
 
@@ -2096,6 +2250,12 @@ class SQLAlchemyStorage:
             session.add(event)
             await self._commit_if_not_in_transaction(session)
 
+        # Send NOTIFY for new outbox event
+        await self._send_notify(
+            "edda_outbox_pending",
+            {"evt_id": event_id, "evt_type": event_type},
+        )
+
     async def get_pending_outbox_events(self, limit: int = 10) -> list[dict[str, Any]]:
         """
         Get pending/failed outbox events for publishing (with row-level locking).
@@ -2719,29 +2879,34 @@ class SQLAlchemyStorage:
     # Workflow Resumption Methods
     # -------------------------------------------------------------------------
 
-    async def find_resumable_workflows(self) -> list[dict[str, Any]]:
+    async def find_resumable_workflows(self, limit: int | None = None) -> list[dict[str, Any]]:
         """
         Find workflows that are ready to be resumed.
 
         Returns workflows with status='running' that don't have an active lock.
         Used for immediate resumption after message delivery.
 
+        Args:
+            limit: Optional maximum number of workflows to return.
+                   If None, returns all resumable workflows.
+
         Returns:
             List of resumable workflows with instance_id and workflow_name.
         """
         session = self._get_session_for_operation()
         async with self._session_scope(session) as session:
-            result = await session.execute(
-                select(
-                    WorkflowInstance.instance_id,
-                    WorkflowInstance.workflow_name,
-                ).where(
-                    and_(
-                        WorkflowInstance.status == "running",
-                        WorkflowInstance.locked_by.is_(None),
-                    )
-                )
-            )
+            query = select(
+                WorkflowInstance.instance_id,
+                WorkflowInstance.workflow_name,
+            ).where(
+                and_(
+                    WorkflowInstance.status == "running",
+                    WorkflowInstance.locked_by.is_(None),
+                )
+            )
+            if limit is not None:
+                query = query.limit(limit)
+            result = await session.execute(query)
             return [
                 {
                     "instance_id": row.instance_id,
@@ -2837,6 +3002,15 @@ 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]
+        await self._send_notify(
+            f"edda_msg_{channel_hash}",
+            {"ch": channel, "msg_id": message_id},
+        )
+
         return message_id
 
     async def subscribe_to_channel(
@@ -3395,6 +3569,12 @@ class SQLAlchemyStorage:
 
                     await session.commit()
 
+                # Send NOTIFY for workflow resumable
+                await self._send_notify(
+                    "edda_workflow_resumable",
+                    {"wf_id": instance_id, "wf_name": workflow_name},
+                )
+
                 return {
                     "instance_id": instance_id,
                     "workflow_name": workflow_name,

edda/viewer_ui/app.py

@@ -1296,6 +1296,8 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
             "search_query": "",
             "started_after": None,
             "started_before": None,
+            "input_filter_key": "",
+            "input_filter_value": "",
             "instances": [],
             "next_page_token": None,
             "has_more": False,
@@ -1352,6 +1354,17 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
                         "click", lambda m=date_to_menu: m.open()
                     )
 
+            # Input data filter fields
+            input_key = ui.input(
+                label="Input Key",
+                placeholder="e.g., input.order_id",
+            ).classes("w-40")
+
+            input_value = ui.input(
+                label="Input Value",
+                placeholder="e.g., ORD-123",
+            ).classes("w-36")
+
             # Refresh button
             async def handle_refresh() -> None:
                 """Handle refresh button click."""
@@ -1360,6 +1373,11 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
                 pagination_state["page_size"] = page_size_select.value
                 pagination_state["started_after"] = date_from.value
                 pagination_state["started_before"] = date_to.value
+                pagination_state["input_filter_key"] = input_key.value
+                pagination_state["input_filter_value"] = input_value.value
+                # Debug output
+                print(f"DEBUG: input_key.value = '{input_key.value}'")
+                print(f"DEBUG: input_value.value = '{input_value.value}'")
                 # Reset to first page
                 pagination_state["current_token"] = None
                 pagination_state["token_stack"] = []
@@ -1389,6 +1407,13 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
                         pagination_state["started_before"] + "T23:59:59"
                     )
 
+            # Build input_filters if key is provided
+            input_filters = None
+            if pagination_state["input_filter_key"]:
+                input_filters = {
+                    pagination_state["input_filter_key"]: pagination_state["input_filter_value"]
+                }
+
             result = await service.get_instances_paginated(
                 page_size=pagination_state["page_size"],
                 page_token=pagination_state["current_token"],
@@ -1396,6 +1421,7 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
                 search_query=pagination_state["search_query"] or None,
                 started_after=started_after,
                 started_before=started_before,
+                input_filters=input_filters,
             )
             pagination_state["instances"] = result["instances"]
             pagination_state["next_page_token"] = result["next_page_token"]

edda/viewer_ui/data_service.py

@@ -48,6 +48,7 @@ class WorkflowDataService:
         search_query: str | None = None,
         started_after: datetime | None = None,
         started_before: datetime | None = None,
+        input_filters: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """
         Get workflow instances with cursor-based pagination and filtering.
@@ -59,6 +60,8 @@ class WorkflowDataService:
             search_query: Search by workflow name or instance ID (partial match)
             started_after: Filter instances started after this datetime
             started_before: Filter instances started before this datetime
+            input_filters: Filter by input data values. Keys are JSON paths
+                (e.g., "order_id"), values are expected values (exact match).
 
         Returns:
             Dictionary containing:
@@ -75,6 +78,7 @@ class WorkflowDataService:
             instance_id_filter=search_query,
             started_after=started_after,
             started_before=started_before,
+            input_filters=input_filters,
         )
         return result
 

{edda_framework-0.9.0.dist-info → edda_framework-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.9.0
+Version: 0.10.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -28,6 +28,8 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: sqlalchemy[asyncio]>=2.0.0
 Requires-Dist: uvloop>=0.22.1
+Provides-Extra: cpu-monitor
+Requires-Dist: psutil>=5.9.0; extra == 'cpu-monitor'
 Provides-Extra: dev
 Requires-Dist: black>=25.9.0; extra == 'dev'
 Requires-Dist: mcp>=1.22.0; extra == 'dev'
@@ -48,6 +50,8 @@ Provides-Extra: opentelemetry
 Requires-Dist: opentelemetry-api>=1.20.0; extra == 'opentelemetry'
 Requires-Dist: opentelemetry-exporter-otlp>=1.20.0; extra == 'opentelemetry'
 Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'opentelemetry'
+Provides-Extra: postgres-notify
+Requires-Dist: asyncpg>=0.30.0; extra == 'postgres-notify'
 Provides-Extra: postgresql
 Requires-Dist: asyncpg>=0.30.0; extra == 'postgresql'
 Provides-Extra: server
@@ -87,6 +91,7 @@ For detailed documentation, visit [https://i2y.github.io/edda/](https://i2y.gith
 - ☁️ **CloudEvents Support**: Native support for CloudEvents protocol
 - ⏱️ **Event & Timer Waiting**: Free up worker resources while waiting for events or timers, resume on any available worker
 - 📬 **Channel-based Messaging**: Actor-model style communication with competing (job queue) and broadcast (fan-out) modes
+- ⚡ **Instant Notifications**: PostgreSQL LISTEN/NOTIFY for near-instant event delivery (optional)
 - 🤖 **MCP Integration**: Expose durable workflows as AI tools via Model Context Protocol
 - 🌍 **ASGI/WSGI Support**: Deploy with your preferred server (uvicorn, gunicorn, uWSGI)
 
@@ -221,6 +226,9 @@ uv add edda-framework --extra mysql
 # With Viewer UI
 uv add edda-framework --extra viewer
 
+# With PostgreSQL instant notifications (LISTEN/NOTIFY)
+uv add edda-framework --extra postgres-notify
+
 # All extras (PostgreSQL, MySQL, Viewer UI)
 uv add edda-framework --extra postgresql --extra mysql --extra viewer
 ```
@@ -272,6 +280,8 @@ pip install "git+https://github.com/i2y/edda.git[postgresql,viewer]"
 
 **Important**: For multi-process or multi-pod deployments (K8s, Docker Compose with multiple replicas, etc.), you **must** use PostgreSQL or MySQL. SQLite supports multiple async workers within a single process, but its table-level locking makes it unsuitable for multi-process/multi-pod scenarios.
 
+> **Tip**: For PostgreSQL, install the `postgres-notify` extra for near-instant event delivery using LISTEN/NOTIFY instead of polling.
+
 ### Development Installation
 
 If you want to contribute to Edda or modify the framework itself:
@@ -492,6 +502,8 @@ app = EddaApp(
     # Connection pool settings (optional)
     pool_size=5,        # Concurrent connections
     max_overflow=10,    # Additional burst capacity
+    # Batch processing (optional)
+    max_workflows_per_batch=10,  # Or "auto" / "auto:cpu" for dynamic scaling
 )
 ```
 

{edda_framework-0.9.0.dist-info → edda_framework-0.10.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
 edda/__init__.py,sha256=hGC6WR2R36M8LWC97F-0Rw4Ln0QUUT_1xC-7acOy_Fk,2237
 edda/activity.py,sha256=nRm9eBrr0lFe4ZRQ2whyZ6mo5xd171ITIVhqytUhOpw,21025
-edda/app.py,sha256=kZ-VEvjIe3GjUA8RhT6OimuezNyPf2IhrvQ2kL44zJs,45201
+edda/app.py,sha256=hoxDKp6q5qHl_dNLMkLxKhuibUC6D8FtuiWsIZkzwhA,61546
 edda/channels.py,sha256=Budi0FyxalmcAMwj50mX3WzRce5OuLKXGws0Hp_snfw,34745
 edda/compensation.py,sha256=iKLlnTxiF1YSatmYQW84EkPB1yMKUEZBtgjuGnghLtY,11824
-edda/context.py,sha256=IavmrbCdTAozP4QWlQ5-rCHR9yJAT-aohqyrOnbVLBU,20858
+edda/context.py,sha256=pPn98-G5HgaOGDRzEhma58TzBulwsiTvmNEMLIu0XwI,21330
 edda/exceptions.py,sha256=-ntBLGpVQgPFG5N1o8m_7weejAYkNrUdxTkOP38vsHk,1766
 edda/hooks.py,sha256=HUZ6FTM__DZjwuomDfTDEroQ3mugEPuJHcGm7CTQNvg,8193
 edda/locking.py,sha256=NAFJmw-JaSVsXn4Y4czJyv_s9bWG8cdrzDBWIEag5X8,13661
@@ -19,25 +19,27 @@ edda/integrations/mcp/server.py,sha256=Q5r4AbMn-9gBcy2CZocbgW7O0fn7Qb4e9CBJa1FEm
 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=2tnN1aOQ8pKWfwEGIlYwYLLwyOKXBjZ4XZsIr1HjgK4,9454
+edda/outbox/relayer.py,sha256=_yOZVpjj862lzMtEK47RMdVdbxXmL8v-FXppZWdy4Ag,10444
 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=Q-kNJsjF8hMc2Q5MYFlLBENKExlNlKkbmUkwBOosj9I,216
+edda/storage/__init__.py,sha256=NjvAzYV3SknACrC16ZQOA-xCKOj1-s3rBIWOS1ZGCaM,407
 edda/storage/models.py,sha256=vUwjiAOvp9uFNQgLK57kEGo7uzXplDZikOfnlOyed2M,12146
-edda/storage/protocol.py,sha256=NTUuLZ5_OlBiASaJIRuz5x7NykpCOjQgDWWNrRQzong,39021
-edda/storage/sqlalchemy_storage.py,sha256=KvSGapeKJ3hhClXNxFKHByD3Key5aidxBMUjs6-EJvE,136811
+edda/storage/notify_base.py,sha256=gUb-ypG1Bo0c-KrleYmC7eKtdwQNUeqGS5k7UILlSsQ,5055
+edda/storage/pg_notify.py,sha256=to5rDIQbiqqkNNVMODye_KvY4EDqRSUQblTeoeDZv8w,11850
+edda/storage/protocol.py,sha256=vdB5GvBen8lgUA0qEfBXfQTLbVfGKeBTQuEwSUqLZtI,39463
+edda/storage/sqlalchemy_storage.py,sha256=IAc8SYHM2xoJEIVDG05_mkguWQGB3wIAALsc0QI8EcE,144484
 edda/viewer_ui/__init__.py,sha256=N1-T33SXadOXcBsDSgJJ9Iqz4y4verJngWryQu70c5c,517
-edda/viewer_ui/app.py,sha256=CqHKsUj5pcysHCk0aRfkEqV4DIV4l3GzOPKBJ5DTYOQ,95624
+edda/viewer_ui/app.py,sha256=K3c5sMeJz_AE9gh5QftxwvfDthLeJi1i2CDkP9gb4Ig,96695
 edda/viewer_ui/components.py,sha256=A0IxLwgj_Lu51O57OfzOwME8jzoJtKegEVvSnWc7uPo,45174
-edda/viewer_ui/data_service.py,sha256=yzmPz67rBoECY7eNK5nl6YS3jIZAi-haaqrP0GIgJYE,36373
+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.9.0.dist-info/METADATA,sha256=esgoKFgUTWqAZWIHxgtKGl5j8VTaWiJw_oz93Dtm064,35741
-edda_framework-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-edda_framework-0.9.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.9.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.9.0.dist-info/RECORD,,
+edda_framework-0.10.0.dist-info/METADATA,sha256=HGJf790N4Rh8EDGIC4e7lFhH8xV5kCQP_xNPTLK8kpE,36366
+edda_framework-0.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+edda_framework-0.10.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.10.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.10.0.dist-info/RECORD,,