flock-core 0.5.0b75__py3-none-any.whl → 0.5.1__py3-none-any.whl

flock/dashboard/models/__init__.py

@@ -0,0 +1 @@
+"""Dashboard models for graph visualization and data structures."""

flock/engines/dspy_engine.py

@@ -242,19 +242,51 @@ class DSPyEngine(EngineComponent):
 
             try:
                 if should_stream:
-                    (
-                        raw_result,
-                        _stream_final_display_data,
-                    ) = await self._execute_streaming(
-                        dspy_mod,
-                        program,
-                        signature,
-                        description=sys_desc,
-                        payload=execution_payload,
-                        agent=agent,
-                        ctx=ctx,
-                        pre_generated_artifact_id=pre_generated_artifact_id,
+                    # Choose streaming method based on dashboard mode
+                    is_dashboard = orchestrator and getattr(orchestrator, "is_dashboard", False)
+
+                    # DEBUG: Log routing decision
+                    logger.info(
+                        f"[STREAMING ROUTER] agent={agent.name}, is_dashboard={is_dashboard}, orchestrator={orchestrator is not None}"
                     )
+
+                    if is_dashboard:
+                        # Dashboard mode: WebSocket-only streaming (no Rich overhead)
+                        # This eliminates the Rich Live context that causes deadlocks with MCP tools
+                        logger.info(
+                            f"[STREAMING ROUTER] Routing {agent.name} to WebSocket-only method (dashboard mode)"
+                        )
+                        (
+                            raw_result,
+                            _stream_final_display_data,
+                        ) = await self._execute_streaming_websocket_only(
+                            dspy_mod,
+                            program,
+                            signature,
+                            description=sys_desc,
+                            payload=execution_payload,
+                            agent=agent,
+                            ctx=ctx,
+                            pre_generated_artifact_id=pre_generated_artifact_id,
+                        )
+                    else:
+                        # CLI mode: Rich streaming with terminal display
+                        logger.info(
+                            f"[STREAMING ROUTER] Routing {agent.name} to Rich streaming method (CLI mode)"
+                        )
+                        (
+                            raw_result,
+                            _stream_final_display_data,
+                        ) = await self._execute_streaming(
+                            dspy_mod,
+                            program,
+                            signature,
+                            description=sys_desc,
+                            payload=execution_payload,
+                            agent=agent,
+                            ctx=ctx,
+                            pre_generated_artifact_id=pre_generated_artifact_id,
+                        )
                     if not self.no_output and ctx:
                         ctx.state["_flock_stream_live_active"] = True
                 else:
@@ -503,6 +535,221 @@ class DSPyEngine(EngineComponent):
         # Handle old format: direct payload (backwards compatible)
         return program(description=description, input=payload, context=[])
 
+    async def _execute_streaming_websocket_only(
+        self,
+        dspy_mod,
+        program,
+        signature,
+        *,
+        description: str,
+        payload: dict[str, Any],
+        agent: Any,
+        ctx: Any = None,
+        pre_generated_artifact_id: Any = None,
+    ) -> tuple[Any, None]:
+        """Execute streaming for WebSocket only (no Rich display).
+
+        Optimized path for dashboard mode that skips all Rich formatting overhead.
+        Used when multiple agents stream in parallel to avoid terminal conflicts
+        and deadlocks with MCP tools.
+
+        This method eliminates the Rich Live context that can cause deadlocks when
+        combined with MCP tool execution and parallel agent streaming.
+        """
+        logger.info(f"Agent {agent.name}: Starting WebSocket-only streaming (dashboard mode)")
+
+        # Get WebSocketManager
+        ws_manager = None
+        if ctx:
+            orchestrator = getattr(ctx, "orchestrator", None)
+            if orchestrator:
+                collector = getattr(orchestrator, "_dashboard_collector", None)
+                if collector:
+                    ws_manager = getattr(collector, "_websocket_manager", None)
+
+        if not ws_manager:
+            logger.warning(
+                f"Agent {agent.name}: No WebSocket manager, falling back to standard execution"
+            )
+            result = await self._execute_standard(
+                dspy_mod, program, description=description, payload=payload
+            )
+            return result, None
+
+        # Get artifact type name for WebSocket events
+        artifact_type_name = "output"
+        if hasattr(agent, "outputs") and agent.outputs:
+            artifact_type_name = agent.outputs[0].spec.type_name
+
+        # Prepare stream listeners
+        listeners = []
+        try:
+            streaming_mod = getattr(dspy_mod, "streaming", None)
+            if streaming_mod and hasattr(streaming_mod, "StreamListener"):
+                for name, field in signature.output_fields.items():
+                    if field.annotation is str:
+                        listeners.append(streaming_mod.StreamListener(signature_field_name=name))
+        except Exception:
+            listeners = []
+
+        # Create streaming task
+        streaming_task = dspy_mod.streamify(
+            program,
+            is_async_program=True,
+            stream_listeners=listeners if listeners else None,
+        )
+
+        # Execute with appropriate payload format
+        if isinstance(payload, dict) and "input" in payload:
+            stream_generator = streaming_task(
+                description=description,
+                input=payload["input"],
+                context=payload.get("context", []),
+            )
+        else:
+            stream_generator = streaming_task(description=description, input=payload, context=[])
+
+        # Process stream (WebSocket only, no Rich display)
+        final_result = None
+        stream_sequence = 0
+
+        # Track background WebSocket broadcast tasks to prevent garbage collection
+        # Using fire-and-forget pattern to avoid blocking DSPy's streaming loop
+        ws_broadcast_tasks: set[asyncio.Task] = set()
+
+        async for value in stream_generator:
+            try:
+                from dspy.streaming import StatusMessage, StreamResponse
+                from litellm import ModelResponseStream
+            except Exception:
+                StatusMessage = object  # type: ignore
+                StreamResponse = object  # type: ignore
+                ModelResponseStream = object  # type: ignore
+
+            if isinstance(value, StatusMessage):
+                token = getattr(value, "message", "")
+                if token:
+                    try:
+                        event = StreamingOutputEvent(
+                            correlation_id=str(ctx.correlation_id)
+                            if ctx and ctx.correlation_id
+                            else "",
+                            agent_name=agent.name,
+                            run_id=ctx.task_id if ctx else "",
+                            output_type="log",
+                            content=str(token + "\n"),
+                            sequence=stream_sequence,
+                            is_final=False,
+                            artifact_id=str(pre_generated_artifact_id),
+                            artifact_type=artifact_type_name,
+                        )
+                        # Fire-and-forget to avoid blocking DSPy's streaming loop
+                        task = asyncio.create_task(ws_manager.broadcast(event))
+                        ws_broadcast_tasks.add(task)
+                        task.add_done_callback(ws_broadcast_tasks.discard)
+                        stream_sequence += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to emit streaming event: {e}")
+
+            elif isinstance(value, StreamResponse):
+                token = getattr(value, "chunk", None)
+                if token:
+                    try:
+                        event = StreamingOutputEvent(
+                            correlation_id=str(ctx.correlation_id)
+                            if ctx and ctx.correlation_id
+                            else "",
+                            agent_name=agent.name,
+                            run_id=ctx.task_id if ctx else "",
+                            output_type="llm_token",
+                            content=str(token),
+                            sequence=stream_sequence,
+                            is_final=False,
+                            artifact_id=str(pre_generated_artifact_id),
+                            artifact_type=artifact_type_name,
+                        )
+                        # Fire-and-forget to avoid blocking DSPy's streaming loop
+                        task = asyncio.create_task(ws_manager.broadcast(event))
+                        ws_broadcast_tasks.add(task)
+                        task.add_done_callback(ws_broadcast_tasks.discard)
+                        stream_sequence += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to emit streaming event: {e}")
+
+            elif isinstance(value, ModelResponseStream):
+                chunk = value
+                token = chunk.choices[0].delta.content or ""
+                if token:
+                    try:
+                        event = StreamingOutputEvent(
+                            correlation_id=str(ctx.correlation_id)
+                            if ctx and ctx.correlation_id
+                            else "",
+                            agent_name=agent.name,
+                            run_id=ctx.task_id if ctx else "",
+                            output_type="llm_token",
+                            content=str(token),
+                            sequence=stream_sequence,
+                            is_final=False,
+                            artifact_id=str(pre_generated_artifact_id),
+                            artifact_type=artifact_type_name,
+                        )
+                        # Fire-and-forget to avoid blocking DSPy's streaming loop
+                        task = asyncio.create_task(ws_manager.broadcast(event))
+                        ws_broadcast_tasks.add(task)
+                        task.add_done_callback(ws_broadcast_tasks.discard)
+                        stream_sequence += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to emit streaming event: {e}")
+
+            elif isinstance(value, dspy_mod.Prediction):
+                final_result = value
+                # Send final events
+                try:
+                    event = StreamingOutputEvent(
+                        correlation_id=str(ctx.correlation_id)
+                        if ctx and ctx.correlation_id
+                        else "",
+                        agent_name=agent.name,
+                        run_id=ctx.task_id if ctx else "",
+                        output_type="log",
+                        content=f"\nAmount of output tokens: {stream_sequence}",
+                        sequence=stream_sequence,
+                        is_final=True,
+                        artifact_id=str(pre_generated_artifact_id),
+                        artifact_type=artifact_type_name,
+                    )
+                    # Fire-and-forget to avoid blocking DSPy's streaming loop
+                    task = asyncio.create_task(ws_manager.broadcast(event))
+                    ws_broadcast_tasks.add(task)
+                    task.add_done_callback(ws_broadcast_tasks.discard)
+
+                    event = StreamingOutputEvent(
+                        correlation_id=str(ctx.correlation_id)
+                        if ctx and ctx.correlation_id
+                        else "",
+                        agent_name=agent.name,
+                        run_id=ctx.task_id if ctx else "",
+                        output_type="log",
+                        content="--- End of output ---",
+                        sequence=stream_sequence + 1,
+                        is_final=True,
+                        artifact_id=str(pre_generated_artifact_id),
+                        artifact_type=artifact_type_name,
+                    )
+                    # Fire-and-forget to avoid blocking DSPy's streaming loop
+                    task = asyncio.create_task(ws_manager.broadcast(event))
+                    ws_broadcast_tasks.add(task)
+                    task.add_done_callback(ws_broadcast_tasks.discard)
+                except Exception as e:
+                    logger.warning(f"Failed to emit final streaming event: {e}")
+
+        if final_result is None:
+            raise RuntimeError(f"Agent {agent.name}: Streaming did not yield a final prediction")
+
+        logger.info(f"Agent {agent.name}: WebSocket streaming completed ({stream_sequence} tokens)")
+        return final_result, None
+
     async def _execute_streaming(
         self,
         dspy_mod,
@@ -930,3 +1177,11 @@ __all__ = ["DSPyEngine"]
 
 # Apply the Rich Live patch when this module is imported
 _apply_live_patch_on_import()
+
+# Apply the DSPy streaming patch to fix deadlocks with MCP tools
+try:
+    from flock.patches.dspy_streaming_patch import apply_patch as apply_dspy_streaming_patch
+
+    apply_dspy_streaming_patch()
+except Exception:
+    pass  # Silently ignore if patch fails to apply

flock/orchestrator.py

@@ -668,8 +668,10 @@ class Flock(metaclass=AutoTracedMeta):
             >>> # Publish with tags for channel routing
             >>> await orchestrator.publish(task, tags={"urgent", "backend"})
         """
-        init_console(clear_screen=True, show_banner=True, model=self.model)
         self.is_dashboard = is_dashboard
+        # Only show banner in CLI mode, not dashboard mode
+        if not self.is_dashboard:
+            init_console(clear_screen=True, show_banner=True, model=self.model)
         # Handle different input types
         if isinstance(obj, Artifact):
             # Already an artifact - publish as-is

flock/patches/__init__.py

@@ -0,0 +1,5 @@
+"""Monkey-patches for third-party libraries to fix known issues."""
+
+from flock.patches.dspy_streaming_patch import apply_patch, restore_original
+
+__all__ = ["apply_patch", "restore_original"]

flock/patches/dspy_streaming_patch.py

@@ -0,0 +1,82 @@
+"""
+Monkey-patch for DSPy's sync_send_to_stream function.
+
+The original DSPy implementation blocks the event loop with future.result(),
+causing deadlocks when using MCP tools with dashboard streaming.
+
+This patch replaces it with a non-blocking fire-and-forget approach.
+"""
+
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def patched_sync_send_to_stream(stream, message):
+    """Non-blocking replacement for DSPy's sync_send_to_stream.
+
+    Instead of blocking with future.result(), this version:
+    1. Schedules the send as a background task (fire-and-forget)
+    2. Never blocks the calling thread
+    3. Logs errors but doesn't raise them
+
+    This allows MCP tool callbacks to complete without deadlocking.
+    """
+
+    async def _send():
+        try:
+            await stream.send(message)
+        except Exception as e:
+            logger.debug(f"DSPy status message send failed (non-critical): {e}")
+
+    try:
+        # Try to get the running event loop
+        loop = asyncio.get_running_loop()
+
+        # Schedule as a background task (fire-and-forget)
+        # This won't block - the task runs independently
+        loop.create_task(_send())
+
+    except RuntimeError:
+        # No event loop running - this is a sync context
+        # We can safely create a new loop and run the task
+        try:
+            asyncio.run(_send())
+        except Exception as e:
+            logger.debug(f"DSPy status message send failed in sync context (non-critical): {e}")
+
+
+def apply_patch():
+    """Apply the monkey-patch to DSPy's streaming module."""
+    try:
+        import dspy.streaming.messages as dspy_messages
+
+        # Store original for reference (in case we need to restore)
+        if not hasattr(dspy_messages, "_original_sync_send_to_stream"):
+            dspy_messages._original_sync_send_to_stream = dspy_messages.sync_send_to_stream
+
+        # Replace with our non-blocking version
+        dspy_messages.sync_send_to_stream = patched_sync_send_to_stream
+
+        logger.info("Applied DSPy streaming patch - status messages are now non-blocking")
+        return True
+
+    except Exception as e:
+        logger.warning(f"Failed to apply DSPy streaming patch: {e}")
+        return False
+
+
+def restore_original():
+    """Restore the original DSPy function (for testing/debugging)."""
+    try:
+        import dspy.streaming.messages as dspy_messages
+
+        if hasattr(dspy_messages, "_original_sync_send_to_stream"):
+            dspy_messages.sync_send_to_stream = dspy_messages._original_sync_send_to_stream
+            logger.info("Restored original DSPy streaming function")
+            return True
+
+    except Exception as e:
+        logger.warning(f"Failed to restore original DSPy function: {e}")
+        return False

{flock_core-0.5.0b75.dist-info → flock_core-0.5.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.5.0b75
-Summary: Add your description here
+Version: 0.5.1
+Summary: Flock: A declrative framework for building and orchestrating AI agents.
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: devtools>=0.12.2
-Requires-Dist: dspy==3.0.0
+Requires-Dist: dspy==3.0.4b1
 Requires-Dist: duckdb>=1.1.0
 Requires-Dist: fastapi>=0.117.1
 Requires-Dist: hanging-threads>=2.0.7
@@ -31,7 +31,7 @@ Requires-Dist: websockets>=15.0.1
 Description-Content-Type: text/markdown
 
 <p align="center">
-  <img alt="Flock Banner" src="https://raw.githubusercontent.com/whiteducksoftware/flock/master/docs/assets/images/flock.png" width="800">
+  <img alt="Flock Banner" src="docs/assets/images/flock.png" width="800">
 </p>
 <p align="center">
   <a href="https://docs.flock.whiteduck.de" target="_blank"><img alt="Documentation" src="https://img.shields.io/badge/docs-online-blue?style=for-the-badge&logo=readthedocs"></a>
@@ -675,13 +675,15 @@ Flock uses a fundamentally different coordination pattern than most multi-agent
 - Type-safe retrieval API (`get_by_type()`)
 
 **⚠️ What's missing for large-scale production:**
-- **Persistent blackboard** - Currently in-memory only
-- **Advanced retry logic** - Basic only
+- **Advanced retry logic** - Basic only (exponential backoff planned)
 - **Event replay** - No Kafka integration yet
 - **Kubernetes-native deployment** - No Helm chart yet
 - **OAuth/RBAC** - Dashboard has no auth
 
-All planned for v1.0
+**✅ Available today:**
+- **Persistent blackboard** - SQLiteBlackboardStore (see above)
+
+All missing features planned for v1.0
 
 ### Recommended Use Cases Today
 
@@ -873,16 +875,21 @@ pip install flock-core
 # Set API key
 export OPENAI_API_KEY="sk-..."
 
-# Try the workshop
+# Try the examples
 git clone https://github.com/whiteducksoftware/flock-flow.git
 cd flock-flow
-uv run python examples/05-claudes-workshop/lesson_01_code_detective.py
+
+# CLI examples with detailed output
+uv run python examples/01-cli/01_declarative_pizza.py
+
+# Dashboard examples with visualization
+uv run python examples/02-dashboard/01_declarative_pizza.py
 ```
 
 **Learn by doing:**
-- 📚 [7-Lesson Workshop](examples/05-claudes-workshop/) - Progressive lessons from basics to advanced
-- 🆚 [The Blackboard](examples/02-the-blackboard/) - See data-driven orchestration without graphs
-- 🎯 [Declarative Basics](examples/01-the-declarative-way/) - Understanding declarative programming
+- 📚 [Examples README](examples/README.md) - 12-step learning path from basics to advanced
+- 🖥️ [CLI Examples](examples/01-cli/) - Detailed console output examples (01-12)
+- 📊 [Dashboard Examples](examples/02-dashboard/) - Interactive visualization examples (01-12)
 - 📖 [Documentation](https://docs.flock.whiteduck.de) - Complete online documentation
 - 📘 [AGENTS.md](AGENTS.md) - Development guide
 
@@ -959,6 +966,6 @@ We're calling this 0.5 to signal:
 
 ---
 
-**Last Updated:** October 8, 2025
+**Last Updated:** October 13, 2025
 **Version:** Flock 0.5.0 (Blackboard Edition)
 **Status:** Production-Ready Core, Enterprise Features Roadmapped

{flock_core-0.5.0b75.dist-info → flock_core-0.5.1.dist-info}/RECORD

@@ -4,7 +4,7 @@ flock/artifacts.py,sha256=3vQQ1J7QxTzeQBUGaNLiyojlmBv1NfdhFC98-qj8fpU,2541
 flock/cli.py,sha256=lPtKxEXnGtyuTh0gyG3ixEIFS4Ty6Y0xsPd6SpUTD3U,4526
 flock/components.py,sha256=17vhNMHKc3VUruEbSdb9YNKcDziIe0coS9jpfWBmX4o,6259
 flock/examples.py,sha256=eQb8k6EYBbUhauFuSN_0EIIu5KW0mTqJU0HM4-p14sc,3632
-flock/orchestrator.py,sha256=g_gxZbOcFsuBk0aw6F41Mbsrc0nF2BBjah6vxvm7rR4,36564
+flock/orchestrator.py,sha256=f7FD1i2bcpkHEER0w3DEgzcWp1AmmBSbegVODdhYxdY,36661
 flock/registry.py,sha256=s0-H-TMtOsDZiZQCc7T1tYiWQg3OZHn5T--jaI_INIc,4786
 flock/runtime.py,sha256=UG-38u578h628mSddBmyZn2VIzFQ0wlHCpCALFiScqA,8518
 flock/service.py,sha256=JDdjjPTPH6NFezAr8x6svtqxIGXA7-AyHS11GF57g9Q,11041
@@ -20,12 +20,13 @@ flock/dashboard/graph_builder.py,sha256=u5Hp007Wr_v3aQI_0YzTit9hAGDc-gUiilnj-p11
 flock/dashboard/launcher.py,sha256=dCfwaeMLtyIkik3aVSEsbBdABS5ADRlKWYkih7sF5hM,8196
 flock/dashboard/service.py,sha256=PzyJS3T3lSoC1sULdfKqUJyu2UUhtSV5xEG0LPhO4qI,39071
 flock/dashboard/websocket.py,sha256=_DCZApJPXc8OQnxFDFS9TA9ozq7kM73QByRj-_a8n-8,9508
+flock/dashboard/models/__init__.py,sha256=T4Yz8IXMm7lBqa2HLDSv7WJBtaKcdZIlTrz6GHNFZxs,68
 flock/dashboard/models/graph.py,sha256=t159CMNavFYZB-qvSE5HRh9Zi_HOR4RYc8VzIngpx_E,5316
 flock/dashboard/static_v2/index.html,sha256=iWL-fgTY2egom20DMvSOpuYZ6pC5AVvdNZcj-EvPm5w,422
 flock/dashboard/static_v2/assets/index-DFRnI_mt.js,sha256=PVrBXxY3Igbf9dqtsWoCbhogEhibapLAwlMYV5Gv4pY,764870
 flock/dashboard/static_v2/assets/index-fPLNdmp1.css,sha256=skpvfkkrlw7WbmBh7HN-rUKAtKP-gpuLUH4klUgFHT4,74529
 flock/engines/__init__.py,sha256=waNyObJ8PKCLFZL3WUFynxSK-V47m559P3Px-vl_OSc,124
-flock/engines/dspy_engine.py,sha256=COb9RBVeT-5uESBhpRV4vShNE70c0gizd5ej-9PEQQ0,38989
+flock/engines/dspy_engine.py,sha256=o_k9mnWuxGN2jEL8KQmaBCGi6Aw8hQb9AZPsQRLRw3U,50921
 flock/frontend/README.md,sha256=R1gqm524Xa5PZAkfl-IJDEf6VsBJ6ThrpY7SyDawjog,26232
 flock/frontend/index.html,sha256=BFg1VR_YVAJ_MGN16xa7sT6wTGwtFYUhfJhGuKv89VM,312
 flock/frontend/package-lock.json,sha256=1edo2JDle0if_MljnK4Xto7Q7hhGUEBQAvQFqKy9RzQ,150798
@@ -181,6 +182,8 @@ flock/mcp/types/handlers.py,sha256=6ukkSMv1VZSfk2QDUiJnm8xifHnQvWZsxWXqN21BYSg,7
 flock/mcp/types/types.py,sha256=ZbzbVihABFnfmZz2X-CCN7hQDzaSY0T-en43PFbFwQQ,11469
 flock/mcp/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/mcp/util/helpers.py,sha256=jO8DqqSb_S4dyvsxv5vlMGRoMx92Su_5-Uv17gQNuLU,740
+flock/patches/__init__.py,sha256=2turkIzq6C_DpIKDwah7aPd-1RFOAGX7dxTkaBd9X4w,193
+flock/patches/dspy_streaming_patch.py,sha256=1vJ7t_PlBBza6MAQPiBhFn2A0k42tdYGs-WpC77BmDA,2762
 flock/themes/3024-day.toml,sha256=uOVHqEzSyHx0WlUk3D0lne4RBsNBAPCTy3C58yU7kEY,667
 flock/themes/3024-night.toml,sha256=qsXUwd6ZYz6J-R129_Ao2TKlvvK60svhZJJjB5c8Tfo,1667
 flock/themes/aardvark-blue.toml,sha256=5ZgsxP3pWLPN3yJ2Wd9ErCo7fy_VJpIfje4kriDKlqo,1667
@@ -518,8 +521,8 @@ flock/themes/zenburned.toml,sha256=UEmquBbcAO3Zj652XKUwCsNoC2iQSlIh-q5c6DH-7Kc,1
 flock/themes/zenwritten-dark.toml,sha256=-dgaUfg1iCr5Dv4UEeHv_cN4GrPUCWAiHSxWK20X1kI,1663
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/utility/output_utility_component.py,sha256=yVHhlIIIoYKziI5UyT_zvQb4G-NsxCTgLwA1wXXTTj4,9047
-flock_core-0.5.0b75.dist-info/METADATA,sha256=lmtrMzJUBxGVur4A4QicG3qw3RzJcUGif0r6pHSzcY4,36377
-flock_core-0.5.0b75.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.5.0b75.dist-info/entry_points.txt,sha256=UQdPmtHd97gSA_IdLt9MOd-1rrf_WO-qsQeIiHWVrp4,42
-flock_core-0.5.0b75.dist-info/licenses/LICENSE,sha256=U3IZuTbC0yLj7huwJdldLBipSOHF4cPf6cUOodFiaBE,1072
-flock_core-0.5.0b75.dist-info/RECORD,,
+flock_core-0.5.1.dist-info/METADATA,sha256=1JRDjG80BKu6R0vwSpZRPXCGlYLKiHoDSVwpRLezdNQ,36531
+flock_core-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.5.1.dist-info/entry_points.txt,sha256=UQdPmtHd97gSA_IdLt9MOd-1rrf_WO-qsQeIiHWVrp4,42
+flock_core-0.5.1.dist-info/licenses/LICENSE,sha256=U3IZuTbC0yLj7huwJdldLBipSOHF4cPf6cUOodFiaBE,1072
+flock_core-0.5.1.dist-info/RECORD,,