flock-core 0.5.0b19__py3-none-any.whl → 0.5.0b21__py3-none-any.whl

flock/components/evaluation/declarative_evaluation_component.py

@@ -1,7 +1,9 @@
 # src/flock/components/evaluation/declarative_evaluation_component.py
 """DeclarativeEvaluationComponent - DSPy-based evaluation using the unified component system."""
 
-from collections.abc import Generator
+from collections import OrderedDict
+from collections.abc import Callable, Generator
+from contextlib import nullcontext
 from typing import Any, Literal, override
 
 from temporalio import workflow
@@ -22,6 +24,73 @@ from flock.core.registry import flock_component
 logger = get_logger("components.evaluation.declarative")
 
 
+_live_patch_applied = False
+
+
+def _ensure_live_crop_above() -> None:
+    """Monkeypatch rich.live_render to support 'crop_above' overflow."""
+    global _live_patch_applied
+    if _live_patch_applied:
+        return
+    try:
+        from typing import Literal as _Literal
+
+        from rich import live_render as _lr
+    except Exception:
+        return
+
+    # Extend the accepted literal at runtime so type checks don't block the new option.
+    current_args = getattr(_lr.VerticalOverflowMethod, '__args__', ())
+    if 'crop_above' not in current_args:
+        _lr.VerticalOverflowMethod = _Literal['crop', 'crop_above', 'ellipsis', 'visible']  # type: ignore[assignment]
+
+    if getattr(_lr.LiveRender.__rich_console__, '_flock_crop_above', False):
+        _live_patch_applied = True
+        return
+
+    Segment = _lr.Segment
+    Text = _lr.Text
+    loop_last = _lr.loop_last
+
+    def _patched_rich_console(self, console, options):
+        renderable = self.renderable
+        style = console.get_style(self.style)
+        lines = console.render_lines(renderable, options, style=style, pad=False)
+        shape = Segment.get_shape(lines)
+
+        _, height = shape
+        max_height = options.size.height
+        if height > max_height:
+            if self.vertical_overflow == 'crop':
+                lines = lines[: max_height]
+                shape = Segment.get_shape(lines)
+            elif self.vertical_overflow == 'crop_above':
+                lines = lines[-max_height:]
+                shape = Segment.get_shape(lines)
+            elif self.vertical_overflow == 'ellipsis' and max_height > 0:
+                lines = lines[: (max_height - 1)]
+                overflow_text = Text(
+                    '...',
+                    overflow='crop',
+                    justify='center',
+                    end='',
+                    style='live.ellipsis',
+                )
+                lines.append(list(console.render(overflow_text)))
+                shape = Segment.get_shape(lines)
+        self._shape = shape
+
+        new_line = Segment.line()
+        for last, line in loop_last(lines):
+            yield from line
+            if not last:
+                yield new_line
+
+    _patched_rich_console._flock_crop_above = True  # type: ignore[attr-defined]
+    _lr.LiveRender.__rich_console__ = _patched_rich_console
+    _live_patch_applied = True
+
+
 class DeclarativeEvaluationConfig(AgentComponentConfig):
     """Configuration for the DeclarativeEvaluationComponent."""
 
@@ -32,6 +101,10 @@ class DeclarativeEvaluationConfig(AgentComponentConfig):
     max_tokens: int = 32000
     max_retries: int = 3
     max_tool_calls: int = 10
+    no_output: bool = Field(
+        default=False,
+        description="Disable output from the underlying DSPy program.",
+    )
     stream: bool = Field(
         default=False,
         description="Enable streaming output from the underlying DSPy program.",
@@ -52,6 +125,11 @@ class DeclarativeEvaluationConfig(AgentComponentConfig):
         default=None,
         description="Extraction LM for TwoStepAdapter when adapter='two_step'",
     )
+    stream_callbacks: list[Callable[..., Any] | Any] | None = None
+    stream_vertical_overflow: Literal["crop", "ellipsis", "crop_above", "visible"] = Field(
+        default="crop_above",
+        description=("Rich Live vertical overflow strategy; select how tall output is handled; 'crop_above' keeps the most recent rows visible."),
+    )
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
 
@@ -165,7 +243,7 @@ class DeclarativeEvaluationComponent(
                 return await self._execute_standard(agent_task, inputs, agent)
 
     async def _execute_streaming(self, signature, agent_task, inputs: dict[str, Any], agent: Any, console) -> dict[str, Any]:
-        """Execute DSPy program in streaming mode (from original implementation)."""
+        """Execute DSPy program in streaming mode with rich table updates."""
         logger.info(f"Evaluating agent '{agent.name}' with async streaming.")
 
         if not callable(agent_task):
@@ -177,7 +255,9 @@ class DeclarativeEvaluationComponent(
         try:
             for name, field in signature.output_fields.items():
                 if field.annotation is str:
-                    listeners.append(dspy.streaming.StreamListener(signature_field_name=name))
+                    listeners.append(
+                        dspy.streaming.StreamListener(signature_field_name=name)
+                    )
         except Exception:
             listeners = []
 
@@ -188,56 +268,148 @@ class DeclarativeEvaluationComponent(
         )
         stream_generator: Generator = streaming_task(**inputs)
 
-        console.print("\n")
+        from collections import defaultdict
+
+        from rich.live import Live
+
+        signature_order = []
+        try:
+            signature_order = list(signature.output_fields.keys())
+        except Exception:
+            signature_order = []
+
+        display_data: OrderedDict[str, Any] = OrderedDict()
+        for key in inputs:
+            display_data[key] = inputs[key]
+
+        for field_name in signature_order:
+            if field_name not in display_data:
+                display_data[field_name] = ""
+
+        stream_buffers: defaultdict[str, list[str]] = defaultdict(list)
+
+        formatter = theme_dict = styles = agent_label = None
+        live_cm = nullcontext()
+        overflow_mode = self.config.stream_vertical_overflow
+        initial_panel = None
+        if not self.config.no_output:
+            _ensure_live_crop_above()
+            (
+                formatter,
+                theme_dict,
+                styles,
+                agent_label,
+            ) = self._prepare_stream_formatter(agent)
+            initial_panel = formatter.format_result(
+                display_data, agent_label, theme_dict, styles
+            )
+            live_cm = Live(
+                initial_panel,
+                console=console,
+                refresh_per_second=400,
+                transient=False,
+                vertical_overflow=overflow_mode,
+            )
+
         final_result: dict[str, Any] | None = None
-        async for value in stream_generator:
-            # Handle DSPy streaming artifacts
-            try:
-                from dspy.streaming import StatusMessage, StreamResponse
-                from litellm import ModelResponseStream
-                import dspy as _d
-            except Exception:
-                StatusMessage = object  # type: ignore
-                StreamResponse = object  # type: ignore
-                ModelResponseStream = object  # type: ignore
-                _d = None
-
-            if isinstance(value, StatusMessage):
-                # Optionally surface status to console
-                console.print(f"[status] {getattr(value, 'message', '')}")
-                continue
-            if isinstance(value, StreamResponse):
-                token = getattr(value, "token", None)
-                if token:
-                    console.print(token, end="")
-                continue
-            if isinstance(value, ModelResponseStream):
-                # Raw model chunk; print minimal content if available for debug
+
+        with live_cm as live:
+            def _refresh_panel() -> None:
+                if formatter is None or live is None:
+                    return
+                live.update(
+                    formatter.format_result(
+                        display_data, agent_label, theme_dict, styles
+                    )
+                )
+
+            async for value in stream_generator:
                 try:
-                    chunk = value
-                    text = chunk.choices[0].delta.content or ""
-                    if text:
-                        console.print(text, end="")
+                    import dspy as _d
+                    from dspy.streaming import StatusMessage, StreamResponse
+                    from litellm import ModelResponseStream
                 except Exception:
-                    pass
-                continue
-            if _d and isinstance(value, _d.Prediction):
-                # Final prediction
-                result_dict, cost, lm_history = self._process_result(value, inputs)
-                self._cost = cost
-                self._lm_history = lm_history
-                final_result = result_dict
-
-        console.print("\n")
+                    StatusMessage = object  # type: ignore
+                    StreamResponse = object  # type: ignore
+                    ModelResponseStream = object  # type: ignore
+                    _d = None
+
+                if isinstance(value, StatusMessage):
+                    message = getattr(value, "message", "")
+                    if message and live is not None:
+                        live.console.log(f"[status] {message}")
+                    continue
+
+                if isinstance(value, StreamResponse):
+                    for callback in self.config.stream_callbacks or []:
+                        try:
+                            callback(value)
+                        except Exception as e:
+                            logger.warning(f"Stream callback error: {e}")
+                    token = getattr(value, "chunk", None)
+                    signature_field = getattr(value, "signature_field_name", None)
+                    if signature_field:
+                        if signature_field not in display_data:
+                            display_data[signature_field] = ""
+                        if token:
+                            stream_buffers[signature_field].append(str(token))
+                            display_data[signature_field] = "".join(
+                                stream_buffers[signature_field]
+                            )
+                        if formatter is not None:
+                            _refresh_panel()
+                    continue
+
+                if isinstance(value, ModelResponseStream):
+                    try:
+                        chunk = value
+                        text = chunk.choices[0].delta.content or ""
+                        if text and live is not None:
+                            live.console.log(text)
+                    except Exception:
+                        pass
+                    continue
+
+                if _d and isinstance(value, _d.Prediction):
+                    result_dict, cost, lm_history = self._process_result(
+                        value, inputs
+                    )
+                    self._cost = cost
+                    self._lm_history = lm_history
+                    final_result = result_dict
+
+                    if formatter is not None:
+                        ordered_final = OrderedDict()
+                        for key in inputs:
+                            if key in final_result:
+                                ordered_final[key] = final_result[key]
+                        for field_name in signature_order:
+                            if field_name in final_result:
+                                ordered_final[field_name] = final_result[field_name]
+                        for key, val in final_result.items():
+                            if key not in ordered_final:
+                                ordered_final[key] = val
+                        display_data.clear()
+                        display_data.update(ordered_final)
+                        _refresh_panel()
+
         if final_result is None:
             raise RuntimeError("Streaming did not yield a final prediction.")
-        final_result = self.filter_reasoning(
+
+        filtered_result = self.filter_reasoning(
             final_result, self.config.include_reasoning
         )
-        return self.filter_thought_process(
-            final_result, self.config.include_thought_process
+        filtered_result = self.filter_thought_process(
+            filtered_result, self.config.include_thought_process
         )
 
+        if not self.config.no_output:
+            context = getattr(agent, "context", None)
+            if context is not None:
+                context.state["_flock_stream_live_active"] = True
+
+        return filtered_result
+
     async def _execute_standard(self, agent_task, inputs: dict[str, Any], agent: Any) -> dict[str, Any]:
         """Execute DSPy program in standard mode (from original implementation)."""
         logger.info(f"Evaluating agent '{agent.name}' without streaming.")
@@ -261,6 +433,62 @@ class DeclarativeEvaluationComponent(
             )
             raise RuntimeError(f"Evaluation failed: {e}") from e
 
+    def _prepare_stream_formatter(
+        self, agent: Any
+    ) -> tuple[Any, dict[str, Any], dict[str, Any], str]:
+        """Build formatter + theme metadata for streaming tables."""
+        import pathlib
+
+        from flock.core.logging.formatters.themed_formatter import (
+            ThemedAgentResultFormatter,
+            create_pygments_syntax_theme,
+            get_default_styles,
+            load_syntax_theme_from_file,
+            load_theme_from_file,
+        )
+        from flock.core.logging.formatters.themes import OutputTheme
+
+        stream_theme = OutputTheme.afterglow
+        output_component = None
+        try:
+            output_component = agent.get_component("output_formatter")
+        except Exception:
+            output_component = None
+        if output_component and getattr(output_component, "config", None):
+            stream_theme = getattr(
+                output_component.config, "theme", stream_theme
+            )
+
+        formatter = ThemedAgentResultFormatter(theme=stream_theme)
+
+        themes_dir = pathlib.Path(__file__).resolve().parents[2] / "themes"
+        theme_filename = stream_theme.value
+        if not theme_filename.endswith(".toml"):
+            theme_filename = f"{theme_filename}.toml"
+        theme_path = themes_dir / theme_filename
+
+        try:
+            theme_dict = load_theme_from_file(theme_path)
+        except Exception:
+            fallback_path = themes_dir / "afterglow.toml"
+            theme_dict = load_theme_from_file(fallback_path)
+            theme_path = fallback_path
+
+        styles = get_default_styles(theme_dict)
+        formatter.styles = styles
+        try:
+            syntax_theme = load_syntax_theme_from_file(theme_path)
+            formatter.syntax_style = create_pygments_syntax_theme(syntax_theme)
+        except Exception:
+            formatter.syntax_style = None
+
+        model_label = getattr(agent, "model", None) or self.config.model or ""
+        agent_label = (
+            agent.name if not model_label else f"{agent.name} - {model_label}"
+        )
+
+        return formatter, theme_dict, styles, agent_label
+
     def filter_thought_process(
         self, result_dict: dict[str, Any], include_thought_process: bool
     ) -> dict[str, Any]:

flock/components/utility/output_utility_component.py

@@ -146,11 +146,23 @@ class OutputUtilityComponent(UtilityComponent):
         """Format and display the output."""
         logger.debug("Formatting and displaying output")
 
+        streaming_live_handled = False
+        if context:
+            streaming_live_handled = bool(
+                context.get_variable("_flock_stream_live_active", False)
+            )
+            if streaming_live_handled:
+                context.state.pop("_flock_stream_live_active", None)
+
         # Determine if output should be suppressed
         is_silent = self.config.no_output or (
             context and context.get_variable(FLOCK_BATCH_SILENT_MODE, False)
         )
 
+        if streaming_live_handled:
+            logger.debug("Skipping static table because streaming rendered live output.")
+            return result
+
         if is_silent:
             logger.debug("Output suppressed (config or batch silent mode).")
             return result  # Skip console output

flock/core/agent/default_agent.py

@@ -8,7 +8,7 @@ and composes the standard components under the hood.
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Any
+from typing import Any, Literal
 
 from flock.components.utility.metrics_utility_component import (
     MetricsUtilityComponent,
@@ -46,7 +46,9 @@ class DefaultAgent(FlockAgent):
         max_tokens: int | None = None,
         max_tool_calls: int = 0,
         max_retries: int = 2,
-        stream: bool = False,
+        stream: bool = True,
+        stream_callbacks: list[Callable[..., Any] | Any] | None = None,
+        stream_vertical_overflow: Literal["crop", "ellipsis", "crop_above", "visible"] = "crop_above",
         include_thought_process: bool = False,
         include_reasoning: bool = False,
         # Output utility parameters
@@ -84,6 +86,8 @@ class DefaultAgent(FlockAgent):
             max_tool_calls: Maximum number of tool calls per evaluation
             max_retries: Maximum retries for failed LLM calls
             stream: Whether to enable streaming responses
+            stream_callbacks: Optional callbacks invoked with each streaming chunk
+            stream_vertical_overflow: Rich Live overflow handling ('ellipsis', 'crop', 'crop_above', 'visible')
             include_thought_process: Include reasoning in output
             include_reasoning: Include detailed reasoning steps
             enable_rich_tables: Enable rich table formatting for output
@@ -119,7 +123,10 @@ class DefaultAgent(FlockAgent):
             temperature=temperature,
             max_tool_calls=max_tool_calls,
             max_retries=max_retries,
+            no_output=no_output,
             stream=stream,
+            stream_callbacks=stream_callbacks,
+            stream_vertical_overflow=stream_vertical_overflow,
             include_thought_process=include_thought_process,
             include_reasoning=include_reasoning,
         )

flock/core/util/cli_helper.py

@@ -51,7 +51,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
 │ ▒█▀▀▀ █░░ █░░█ █░░ █▀▄ │
 │ ▒█░░░ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀░▀ │
-╰━━━━━━━━v{__version__}━━━━━━━━╯
+╰━━━━━━━━v{__version__}━━━━━━━╯
 🦆     🐤    🐧     🐓
 """,
         justify="center",
@@ -63,11 +63,11 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
     if show_banner:
         console.print(banner_text)
         console.print(
-            "[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+            "[italic]'Kea'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
         )
 
     if model:
-        console.print(f"[italic]Global Model:[/] {model}")
+        console.print(f"[italic]Global Model:[/] {model}\n")
 
 
 def display_banner_no_version():

{flock_core-0.5.0b19.dist-info → flock_core-0.5.0b21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.5.0b19
+Version: 0.5.0b21
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.5.0b19.dist-info → flock_core-0.5.0b21.dist-info}/RECORD

@@ -27,7 +27,7 @@ flock/cli/yaml_editor.py,sha256=K3N0bh61G1TSDAZDnurqW9e_-hO6CtSQKXQqlDhCjVo,1252
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/components/__init__.py,sha256=qDcaP0O7_b5RlUEXluqwskpKCkhM73kSMeNXReze63M,963
 flock/components/evaluation/__init__.py,sha256=_M3UlRFeNN90fEny6byt5VdLDE5o5khbd0EPT0o9S9k,303
-flock/components/evaluation/declarative_evaluation_component.py,sha256=OXuJlH7TTQAy3upg3K68oSr4cS89XlSty2GeM3l6fDs,11606
+flock/components/evaluation/declarative_evaluation_component.py,sha256=a-RPCcpdXq66XFSPYite2OYwC_5Cnckf4VQK1ie1E-w,20269
 flock/components/routing/__init__.py,sha256=BH_pFm9T6bUuf8HH4byDJ0dO0fzEVHv9m-ghUdDVdm0,542
 flock/components/routing/conditional_routing_component.py,sha256=WqZLMz-0Dhfb97xvttNrJCIVe6FNMLEQ2m4KQTDpIbI,21374
 flock/components/routing/default_routing_component.py,sha256=ZHt2Kjf-GHB5n7evU5NSGeQJ1Wuims5soeMswqaUb1E,3370
@@ -35,7 +35,7 @@ flock/components/routing/llm_routing_component.py,sha256=SAaOFjlnhnenM6QEBn3WIpj
 flock/components/utility/__init__.py,sha256=JRj932upddjzZMWs1avOupEFr_GZNu21ac66Rhw_XgY,532
 flock/components/utility/memory_utility_component.py,sha256=26Io61bbCGjD8UQ4BltMA5RLkMXp8tQoQmddXbQSrzA,20183
 flock/components/utility/metrics_utility_component.py,sha256=Mck_sFCkfXvNpoSgW2N_WOLnjxazzx8jh79tIx5zJhw,24635
-flock/components/utility/output_utility_component.py,sha256=c4K_PL3bGqdyy_v6dnOrmTqV-MkWKAB2w0HS8kzg82k,7613
+flock/components/utility/output_utility_component.py,sha256=TdHhY5qJJDUk-_LK54zAFMSG_Zafe-UiEkwiJwPjfh0,8063
 flock/core/__init__.py,sha256=OkjsVjRkAB-I6ibeTKVikZ3MxLIcTIzWKphHTbzbr7s,3231
 flock/core/flock.py,sha256=wRycQlGeaq-Vd75mFpPe02qyWTOEyXthT873iBhA3TI,23388
 flock/core/flock_agent.py,sha256=4Vdhyk-rdsPEuN3xYBsLBBsfpklad6bNj_it9r6XIDc,12868
@@ -43,7 +43,7 @@ flock/core/flock_factory.py,sha256=Z6GJpYXN9_DXuOqvBH9ir0SMoUw78DkWhrhkm90luAQ,2
 flock/core/flock_scheduler.py,sha256=ng_s7gyijmc-AmYvBn5rtg61CSUZiIkXPRSlA1xO6VQ,8766
 flock/core/flock_server_manager.py,sha256=tM_nOs37vAbEvxmhwy_DL2JPvgFViWroNxrRSu5MfUQ,4523
 flock/core/agent/__init__.py,sha256=l32KFMJnC_gidMXpAXK8-OX228bWOhNc8OY_NzXm59Q,515
-flock/core/agent/default_agent.py,sha256=W5ewr4l4adjZjstcCvr6S8r2EnrmH0wFOVEtA8OQprI,6962
+flock/core/agent/default_agent.py,sha256=924SWDx8axJ57JCWREZuLzV8039Wt_-5WIBNTvx479Y,7483
 flock/core/agent/flock_agent_components.py,sha256=LamOgpRC7wDKuU3d6enDG0UFlNxyKPErLpH7SQ_Pi74,4539
 flock/core/agent/flock_agent_execution.py,sha256=pdOddBGv8y1P89Ix8XFWa1eW9i3bWjOYiQQxeY2K0yo,4217
 flock/core/agent/flock_agent_integration.py,sha256=fnxzEA8-gIopHwD1de8QKt2A7Ilb1iH5Koxk1uiASas,10737
@@ -125,7 +125,7 @@ flock/core/serialization/json_encoder.py,sha256=gAKj2zU_8wQiNvdkby2hksSA4fbPNwTj
 flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
 flock/core/serialization/serializable.py,sha256=qlv8TsTqRuklXiNuCMrvro5VKz764xC2i3FlgLJSkdk,12129
 flock/core/serialization/serialization_utils.py,sha256=kxsuWy-8kFBcihHQvSOSNYp96ZPKxBMnasyRTtvIktY,15532
-flock/core/util/cli_helper.py,sha256=w8N7UJZOdOFhkcUSSusnL22JDlmJGgWmH0DgO--j-5c,50057
+flock/core/util/cli_helper.py,sha256=upRcEvWdGTrZvaKhi701PtFyW-Wp_B8PY3Gt0QY9szY,50053
 flock/core/util/file_path_utils.py,sha256=Odf7uU32C-x1KNighbNERSiMtkzW4h8laABIoFK7A5M,6246
 flock/core/util/hydrator.py,sha256=qRfVTDBEwqv1-ET2D4s5NI25f-UA_tGsoAmt5jaJMDI,10693
 flock/core/util/input_resolver.py,sha256=t3C98xz_-LGnDH0YeWQyV8yKZrls-_ekOYR-IKrAXDs,6232
@@ -551,8 +551,8 @@ flock/workflow/agent_execution_activity.py,sha256=0exwmeWKYXXxdUqDf4YaUVpn0zl06S
 flock/workflow/flock_workflow.py,sha256=sKFsRIL_bDGonXSNhK1zwu6UechghC_PihJJMidI-VI,9139
 flock/workflow/temporal_config.py,sha256=3_8O7SDEjMsSMXsWJBfnb6XTp0TFaz39uyzSlMTSF_I,3988
 flock/workflow/temporal_setup.py,sha256=KR6MlWOrpMtv8NyhaIPAsfl4tjobt81OBByQvg8Kw-Y,1948
-flock_core-0.5.0b19.dist-info/METADATA,sha256=IIENs1thHIvHmhkyhR3G62jimiMS7_ImCmVLv3AKAlQ,9997
-flock_core-0.5.0b19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.5.0b19.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.5.0b19.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.5.0b19.dist-info/RECORD,,
+flock_core-0.5.0b21.dist-info/METADATA,sha256=UV0JZGY5epos-_zJXKP6msrOE9M21KBkIlDRVvbXzvk,9997
+flock_core-0.5.0b21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.5.0b21.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.5.0b21.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.5.0b21.dist-info/RECORD,,