edda-framework 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

edda/viewer_ui/app.py

@@ -1600,7 +1600,12 @@ def start_viewer(edda_app: EddaApp, port: int = 8080, reload: bool = False) -> N
             with ui.row().classes("gap-4 items-center"):
                 # Cancel button (only show for running/waiting workflows)
                 status = instance["status"]
-                if status in ["running", "waiting_for_event", "waiting_for_timer"]:
+                if status in [
+                    "running",
+                    "waiting_for_event",
+                    "waiting_for_timer",
+                    "waiting_for_message",
+                ]:
 
                     async def handle_cancel() -> None:
                         """Handle workflow cancellation."""

edda/viewer_ui/data_service.py

@@ -267,7 +267,7 @@ class WorkflowDataService:
         except (OSError, TypeError) as e:
             # OSError: source not available (e.g., interactive shell)
             # TypeError: not a module, class, method, function, etc.
-            print(f"Warning: Could not get source for {workflow_name}: {e}")
+            logger.warning("Could not get source for %s: %s", workflow_name, e)
             return None
 
     async def get_activity_executions(
@@ -332,8 +332,8 @@ class WorkflowDataService:
         import httpx
 
         try:
-            print(f"[Cancel] Attempting to cancel workflow: {instance_id}")
-            print(f"[Cancel] API URL: {edda_app_url}/cancel/{instance_id}")
+            logger.debug("Attempting to cancel workflow: %s", instance_id)
+            logger.debug("API URL: %s/cancel/%s", edda_app_url, instance_id)
 
             async with httpx.AsyncClient() as client:
                 response = await client.post(
@@ -341,8 +341,8 @@ class WorkflowDataService:
                     timeout=10.0,
                 )
 
-                print(f"[Cancel] Response status: {response.status_code}")
-                print(f"[Cancel] Response body: {response.text}")
+                logger.debug("Response status: %s", response.status_code)
+                logger.debug("Response body: %s", response.text)
 
                 if 200 <= response.status_code < 300:
                     return True, "Workflow cancelled successfully"
@@ -356,17 +356,17 @@ class WorkflowDataService:
 
         except httpx.ConnectError as e:
             error_msg = f"Cannot connect to EddaApp at {edda_app_url}. Is it running?"
-            print(f"[Cancel] Connection error: {e}")
+            logger.warning("Connection error: %s", e)
             return False, error_msg
 
         except httpx.TimeoutException as e:
             error_msg = "Request timed out. The server may be busy."
-            print(f"[Cancel] Timeout error: {e}")
+            logger.warning("Timeout error: %s", e)
             return False, error_msg
 
         except Exception as e:
             error_msg = f"Unexpected error: {type(e).__name__}: {str(e)}"
-            print(f"[Cancel] Unexpected error: {e}")
+            logger.error("Unexpected error: %s", e, exc_info=True)
             return False, error_msg
 
     def get_all_workflows(self) -> dict[str, Any]:
@@ -520,7 +520,7 @@ class WorkflowDataService:
                 }
             except Exception as e:
                 # Fallback to JSON if schema generation fails
-                print(f"Warning: Failed to generate JSON Schema for {annotation}: {e}")
+                logger.warning("Failed to generate JSON Schema for %s: %s", annotation, e)
                 return {"type": "json"}
 
         # Check if it's an Enum
@@ -856,9 +856,9 @@ class WorkflowDataService:
         from cloudevents.http import CloudEvent
 
         try:
-            print(f"[StartWorkflow] Attempting to start workflow: {workflow_name}")
-            print(f"[StartWorkflow] Sending CloudEvent to: {edda_app_url}")
-            print(f"[StartWorkflow] Params: {params}")
+            logger.debug("Attempting to start workflow: %s", workflow_name)
+            logger.debug("Sending CloudEvent to: %s", edda_app_url)
+            logger.debug("Params: %s", params)
 
             # Verify workflow exists
             all_workflows = self.get_all_workflows()
@@ -876,8 +876,8 @@ class WorkflowDataService:
             # Convert to HTTP format (structured content mode)
             headers, body = to_structured(event)
 
-            print(f"[StartWorkflow] CloudEvent ID: {attributes['id']}")
-            print(f"[StartWorkflow] CloudEvent type: {workflow_name}")
+            logger.debug("CloudEvent ID: %s", attributes["id"])
+            logger.debug("CloudEvent type: %s", workflow_name)
 
             # Send CloudEvent to EddaApp
             async with httpx.AsyncClient() as client:
@@ -888,8 +888,8 @@ class WorkflowDataService:
                     timeout=10.0,
                 )
 
-                print(f"[StartWorkflow] Response status: {response.status_code}")
-                print(f"[StartWorkflow] Response body: {response.text}")
+                logger.debug("Response status: %s", response.status_code)
+                logger.debug("Response body: %s", response.text)
 
                 if 200 <= response.status_code < 300:
                     # CloudEvent accepted (200 OK or 202 Accepted)
@@ -902,18 +902,15 @@ class WorkflowDataService:
 
         except httpx.ConnectError as e:
             error_msg = f"Cannot connect to EddaApp at {edda_app_url}. Is it running?"
-            print(f"[StartWorkflow] Connection error: {e}")
+            logger.warning("Connection error: %s", e)
             return False, error_msg, None
 
         except httpx.TimeoutException as e:
             error_msg = "Request timed out. The server may be busy."
-            print(f"[StartWorkflow] Timeout error: {e}")
+            logger.warning("Timeout error: %s", e)
             return False, error_msg, None
 
         except Exception as e:
             error_msg = f"Unexpected error: {type(e).__name__}: {str(e)}"
-            print(f"[StartWorkflow] Unexpected error: {e}")
-            import traceback
-
-            traceback.print_exc()
+            logger.error("Unexpected error: %s", e, exc_info=True)
             return False, error_msg, None

edda/workflow.py

@@ -14,6 +14,49 @@ from edda.pydantic_utils import to_json_dict
 
 F = TypeVar("F", bound=Callable[..., Any])
 
+
+class RecurException(Exception):
+    """
+    Exception raised to signal that a workflow should recur (restart with fresh history).
+
+    This is similar to Erlang's tail recursion pattern - it prevents unbounded history
+    growth in long-running loops by completing the current workflow instance and
+    starting a new one with the provided arguments.
+
+    The workflow's history is archived (not deleted) and a new instance is created
+    with a reference to the previous instance (continued_from).
+
+    Note:
+        This exception should not be caught by user code. It is handled internally
+        by the ReplayEngine.
+
+    Example:
+        >>> @workflow
+        ... async def notification_service(ctx: WorkflowContext, processed_count: int = 0):
+        ...     await join_group(ctx, group="order_watchers")
+        ...
+        ...     count = 0
+        ...     while True:
+        ...         msg = await wait_message(ctx, channel="order.completed")
+        ...         await send_notification(ctx, msg.data, activity_id=f"notify:{msg.id}")
+        ...
+        ...         count += 1
+        ...         if count >= 1000:
+        ...             # Reset history by recurring with new state
+        ...             await ctx.recur(processed_count=processed_count + count)
+    """
+
+    def __init__(self, kwargs: dict[str, Any]):
+        """
+        Initialize RecurException.
+
+        Args:
+            kwargs: Keyword arguments to pass to the new workflow instance
+        """
+        self.kwargs = kwargs
+        super().__init__("Workflow recur requested")
+
+
 # Global registry of workflow instances (will be set by EddaApp)
 _replay_engine: Any = None
 

{edda_framework-0.7.0.dist-info → edda_framework-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.7.0
+Version: 0.8.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -85,6 +85,7 @@ For detailed documentation, visit [https://i2y.github.io/edda/](https://i2y.gith
 - 📦 **Transactional Outbox**: Reliable event publishing with guaranteed delivery
 - ☁️ **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
 - 🤖 **MCP Integration**: Expose durable workflows as AI tools via Model Context Protocol
 - 🌍 **ASGI/WSGI Support**: Deploy with your preferred server (uvicorn, gunicorn, uWSGI)
 
@@ -107,14 +108,14 @@ Edda's waiting functions make it ideal for time-based and event-driven business
 - **📦 Scheduled Notifications**: Shipping updates, subscription renewals, appointment reminders
 
 **Waiting functions**:
-- `wait_timer(duration_seconds)`: Wait for a relative duration
-- `wait_until(until_time)`: Wait until an absolute datetime (e.g., campaign end date)
+- `sleep(seconds)`: Wait for a relative duration
+- `sleep_until(target_time)`: Wait until an absolute datetime (e.g., campaign end date)
 - `wait_event(event_type)`: Wait for external events (near real-time response)
 
 ```python
 @workflow
 async def onboarding_reminder(ctx: WorkflowContext, user_id: str):
-    await wait_timer(ctx, duration_seconds=3*24*60*60)  # Wait 3 days
+    await sleep(ctx, seconds=3*24*60*60)  # Wait 3 days
     if not await check_completed(ctx, user_id):
         await send_reminder(ctx, user_id)
 ```
@@ -166,7 +167,7 @@ graph TB
 
 - Multiple workers can run simultaneously across different pods/servers
 - Each workflow instance runs on only one worker at a time (automatic coordination)
-- `wait_event()` and `wait_timer()` free up worker resources while waiting, resume on any worker when event arrives or timer expires
+- `wait_event()` and `sleep()` free up worker resources while waiting, resume on any worker when event arrives or timer expires
 - Automatic crash recovery with stale lock cleanup and workflow auto-resume
 
 ## Quick Start
@@ -486,7 +487,10 @@ Multiple workers can safely process workflows using database-based exclusive con
 
 app = EddaApp(
     db_url="postgresql://localhost/workflows",  # Shared database for coordination
-    service_name="order-service"
+    service_name="order-service",
+    # Connection pool settings (optional)
+    pool_size=5,        # Concurrent connections
+    max_overflow=10,    # Additional burst capacity
 )
 ```
 
@@ -614,10 +618,32 @@ async def payment_workflow(ctx: WorkflowContext, order_id: str):
     return payment_event.data
 ```
 
-**wait_timer() for time-based waiting**:
+**ReceivedEvent attributes**: The `wait_event()` function returns a `ReceivedEvent` object:
+
+```python
+event = await wait_event(ctx, "payment.completed")
+amount = event.data["amount"]           # Event payload (dict or bytes)
+source = event.metadata.source          # CloudEvents source
+event_type = event.metadata.type        # CloudEvents type
+extensions = event.extensions           # CloudEvents extensions
+```
+
+**Timeout handling with EventTimeoutError**:
 
 ```python
-from edda import wait_timer
+from edda import wait_event, EventTimeoutError
+
+try:
+    event = await wait_event(ctx, "payment.completed", timeout_seconds=60)
+except EventTimeoutError:
+    # Handle timeout (e.g., cancel order, send reminder)
+    await cancel_order(ctx, order_id)
+```
+
+**sleep() for time-based waiting**:
+
+```python
+from edda import sleep
 
 @workflow
 async def order_with_timeout(ctx: WorkflowContext, order_id: str):
@@ -625,7 +651,7 @@ async def order_with_timeout(ctx: WorkflowContext, order_id: str):
     await create_order(ctx, order_id)
 
     # Wait 60 seconds for payment
-    await wait_timer(ctx, duration_seconds=60)
+    await sleep(ctx, seconds=60)
 
     # Check payment status
     return await check_payment(ctx, order_id)
@@ -639,6 +665,136 @@ async def order_with_timeout(ctx: WorkflowContext, order_id: str):
 
 **For technical details**, see [Multi-Worker Continuations](local-docs/distributed-coroutines.md).
 
+### Message Passing (Workflow-to-Workflow)
+
+Edda provides actor-model style message passing for direct workflow-to-workflow communication:
+
+```python
+from edda import workflow, wait_message, send_message_to, WorkflowContext
+
+# Receiver workflow - waits for approval message
+@workflow
+async def approval_workflow(ctx: WorkflowContext, request_id: str):
+    # Wait for message on "approval" channel
+    msg = await wait_message(ctx, channel="approval")
+
+    if msg.data["approved"]:
+        return {"status": "approved", "approver": msg.data["approver"]}
+    return {"status": "rejected"}
+
+# Sender workflow - sends approval decision
+@workflow
+async def manager_workflow(ctx: WorkflowContext, request_id: str):
+    # Review and make decision
+    decision = await review_request(ctx, request_id)
+
+    # Send message to waiting workflow
+    await send_message_to(
+        ctx,
+        target_instance_id=request_id,
+        channel="approval",
+        data={"approved": decision, "approver": "manager-123"},
+    )
+```
+
+**Group Communication (Erlang pg style)** - for fan-out messaging without knowing receiver instance IDs:
+
+```python
+from edda import workflow, join_group, wait_message, publish_to_group
+
+# Receiver workflow - joins a group and listens
+@workflow
+async def notification_service(ctx: WorkflowContext, service_id: str):
+    # Join group at startup (loose coupling - sender doesn't need to know us)
+    await join_group(ctx, group="order_watchers")
+
+    while True:
+        msg = await wait_message(ctx, channel="order.created")
+        await send_notification(ctx, msg.data)
+
+# Sender workflow - publishes to all group members
+@workflow
+async def order_processor(ctx: WorkflowContext, order_id: str):
+    result = await process_order(ctx, order_id)
+
+    # Broadcast to all watchers (doesn't need to know instance IDs)
+    count = await publish_to_group(
+        ctx,
+        group="order_watchers",
+        channel="order.created",
+        data={"order_id": order_id, "status": "completed"},
+    )
+    print(f"Notified {count} watchers")
+```
+
+**Channel API with Delivery Modes** - subscribe to channels with explicit delivery semantics:
+
+```python
+from edda import workflow, subscribe, receive, publish, WorkflowContext
+
+# Job Worker - processes jobs exclusively (competing mode)
+@workflow
+async def job_worker(ctx: WorkflowContext, worker_id: str):
+    # Subscribe with competing mode - each job goes to ONE worker only
+    await subscribe(ctx, channel="jobs", mode="competing")
+
+    while True:
+        job = await receive(ctx, channel="jobs")  # Get next job
+        await process_job(ctx, job.data)
+        await ctx.recur(worker_id)  # Continue processing
+
+# Notification Handler - receives ALL messages (broadcast mode)
+@workflow
+async def notification_handler(ctx: WorkflowContext, handler_id: str):
+    # Subscribe with broadcast mode - ALL handlers receive each message
+    await subscribe(ctx, channel="notifications", mode="broadcast")
+
+    while True:
+        msg = await receive(ctx, channel="notifications")
+        await send_notification(ctx, msg.data)
+        await ctx.recur(handler_id)
+
+# Publisher - send messages to channel
+await publish(ctx, channel="jobs", data={"task": "send_report"})
+```
+
+**Delivery modes**:
+- **`competing`**: Each message goes to exactly ONE subscriber (job queue/task distribution)
+- **`broadcast`**: Each message goes to ALL subscribers (notifications/fan-out)
+
+**Key features**:
+- **Channel-based messaging**: Messages are delivered to workflows waiting on specific channels
+- **Competing vs Broadcast**: Choose semantics per subscription
+- **Group communication**: Erlang pg-style groups for loose coupling and fan-out
+- **Database-backed**: All messages are persisted for durability
+- **Lock-first delivery**: Safe for multi-worker environments
+
+### Workflow Recurrence
+
+Long-running workflows can use `ctx.recur()` to restart with fresh history while maintaining the same instance ID. This is essential for workflows that run indefinitely (job workers, notification handlers, etc.):
+
+```python
+from edda import workflow, subscribe, receive, WorkflowContext
+
+@workflow
+async def job_worker(ctx: WorkflowContext, worker_id: str):
+    await subscribe(ctx, channel="jobs", mode="competing")
+
+    # Process one job
+    job = await receive(ctx, channel="jobs")
+    await process_job(ctx, job.data)
+
+    # Archive history and restart with same instance_id
+    # Prevents unbounded history growth
+    await ctx.recur(worker_id)
+```
+
+**Key benefits**:
+- **Prevents history growth**: Archives old history, starts fresh
+- **Maintains instance ID**: Same workflow continues logically
+- **Preserves subscriptions**: Channel subscriptions survive recurrence
+- **Enables infinite loops**: Essential for long-running workers
+
 ### ASGI Integration
 
 Edda runs as an ASGI application:

{edda_framework-0.7.0.dist-info → edda_framework-0.8.0.dist-info}/RECORD

@@ -1,23 +1,23 @@
-edda/__init__.py,sha256=gmJd0ooVbGNMOLlSj-r6rEt3IkY-FZYCFjhWjIltqlk,1657
+edda/__init__.py,sha256=hGC6WR2R36M8LWC97F-0Rw4Ln0QUUT_1xC-7acOy_Fk,2237
 edda/activity.py,sha256=nRm9eBrr0lFe4ZRQ2whyZ6mo5xd171ITIVhqytUhOpw,21025
-edda/app.py,sha256=8FKx9Kspbm5Fz-QDz4DgncNkkgdZkij209LHllWkRw4,38288
-edda/compensation.py,sha256=CmnyJy4jAklVrtLJodNOcj6vxET6pdarxM1Yx2RHlL4,11898
-edda/context.py,sha256=YZKBNtblRcaFqte1Y9t2cIP3JHzK-5Tu40x5i5FHtnU,17789
-edda/events.py,sha256=KN06o-Umkwkg9-TwbN4jr1uBZrBrvVSc6m8mOlQGXkA,18043
+edda/app.py,sha256=kZ-VEvjIe3GjUA8RhT6OimuezNyPf2IhrvQ2kL44zJs,45201
+edda/channels.py,sha256=ozaXCcWMLwgu_i6p8I79C9FnfsoQ0uv2BpaPPonTJdc,33863
+edda/compensation.py,sha256=iKLlnTxiF1YSatmYQW84EkPB1yMKUEZBtgjuGnghLtY,11824
+edda/context.py,sha256=kxWok86IwLF7hvxlE803t7ayPySTzCKoW113TmwON1k,19752
 edda/exceptions.py,sha256=-ntBLGpVQgPFG5N1o8m_7weejAYkNrUdxTkOP38vsHk,1766
 edda/hooks.py,sha256=HUZ6FTM__DZjwuomDfTDEroQ3mugEPuJHcGm7CTQNvg,8193
-edda/locking.py,sha256=l3YM7zdERizw27jQXfLN7EmcMcrJSVzd7LD8hhsXvIM,11003
+edda/locking.py,sha256=NAFJmw-JaSVsXn4Y4czJyv_s9bWG8cdrzDBWIEag5X8,13661
 edda/pydantic_utils.py,sha256=dGVPNrrttDeq1k233PopCtjORYjZitsgASPfPnO6R10,9056
-edda/replay.py,sha256=5RIRd0q2ZrH9iiiy35eOUii2cipYg9dlua56OAXvIk4,32499
+edda/replay.py,sha256=_poGUfvsDJP8GiflAw6aCZzxMKJpo99z__JVdGHb75I,42567
 edda/retry.py,sha256=t4_E1skrhotA1XWHTLbKi-DOgCMasOUnhI9OT-O_eCE,6843
-edda/workflow.py,sha256=daSppYAzgXkjY_9-HS93Zi7_tPR6srmchxY5YfwgU-4,7239
+edda/workflow.py,sha256=hfBZM0JrtK0IkvZSrva0VmYVyvKCdiJ5FWFmIVENfrM,8807
 edda/wsgi.py,sha256=1pGE5fhHpcsYnDR8S3NEFKWUs5P0JK4roTAzX9BsIj0,2391
 edda/integrations/__init__.py,sha256=F_CaTvlDEbldfOpPKq_U9ve1E573tS6XzqXnOtyHcXI,33
 edda/integrations/mcp/__init__.py,sha256=YK-8m0DIdP-RSqewlIX7xnWU7TD3NioCiW2_aZSgnn8,1232
 edda/integrations/mcp/decorators.py,sha256=31SmbDwmHEGvUNa3aaatW91hBkpnS5iN9uy47dID3J4,10037
 edda/integrations/mcp/server.py,sha256=Q5r4AbMn-9gBcy2CZocbgW7O0fn7Qb4e9CBJa1FEmzU,14507
 edda/integrations/opentelemetry/__init__.py,sha256=x1_PyyygGDW-rxQTwoIrGzyjKErXHOOKdquFAMlCOAo,906
-edda/integrations/opentelemetry/hooks.py,sha256=FBYnSZBh8_0vw9M1E2AbJrx1cTTsKeiHf5wspr0UnzU,21288
+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/transactional.py,sha256=LFfUjunqRlGibaINi-efGXFFivWGO7v3mhqrqyGW6Nw,3808
@@ -25,19 +25,19 @@ edda/serialization/__init__.py,sha256=hnOVJN-mJNIsSa_XH9jwhIydOsWvIfCaFaSd37HUpl
 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/models.py,sha256=usVPKLV4H1-LA6QC72_gkfYrG9T8AwkcmCXppBo-2gQ,7338
-edda/storage/protocol.py,sha256=j1YNW1TepuLvPvn7wCcPVIehs0obD30cGOMcyqMwtlA,25852
-edda/storage/sqlalchemy_storage.py,sha256=dZ0ulDp6CuZEtDzkD0g76x4ew-dseLWRXrULVsW_isk,76258
+edda/storage/models.py,sha256=E_KFygX6DP2qRwgLGLiKPhcXdKtvnfKeqA2kMXcAchE,13188
+edda/storage/protocol.py,sha256=0E5QSUDtSMlJX_lF6m3VAUx3WO6Qjm-Kq6_bXI7P52I,39841
+edda/storage/sqlalchemy_storage.py,sha256=eswQxCyY2DdUNYdrkxW_7Pev6CHCohNb72kGJjf29tA,140825
 edda/viewer_ui/__init__.py,sha256=N1-T33SXadOXcBsDSgJJ9Iqz4y4verJngWryQu70c5c,517
-edda/viewer_ui/app.py,sha256=Zf-ZMDWhmaTuKGJbb27NTQoLhOXMlF-aqRJ7VsC9BwA,95502
+edda/viewer_ui/app.py,sha256=CqHKsUj5pcysHCk0aRfkEqV4DIV4l3GzOPKBJ5DTYOQ,95624
 edda/viewer_ui/components.py,sha256=A0IxLwgj_Lu51O57OfzOwME8jzoJtKegEVvSnWc7uPo,45174
-edda/viewer_ui/data_service.py,sha256=IK5I9Y2eho5VJz63DhBKuTEsS3LqkeV24Ctc75OGxDM,36478
+edda/viewer_ui/data_service.py,sha256=yzmPz67rBoECY7eNK5nl6YS3jIZAi-haaqrP0GIgJYE,36373
 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.7.0.dist-info/METADATA,sha256=d2PVbDx-LymunfaAs13Hvxb1U8dOf-NR4VmX6whrrP0,31794
-edda_framework-0.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-edda_framework-0.7.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.7.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.7.0.dist-info/RECORD,,
+edda_framework-0.8.0.dist-info/METADATA,sha256=o5ANdknKkLtOAGnKZ_IIQ0D3Q2iKyccdYVB-jjf8LLA,37506
+edda_framework-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+edda_framework-0.8.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.8.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.8.0.dist-info/RECORD,,