flock-core 0.4.0b26__py3-none-any.whl → 0.4.0b27__py3-none-any.whl

flock/workflow/flock_workflow.py

@@ -1,12 +1,22 @@
 from datetime import timedelta
+from typing import Any
 
 from temporalio import workflow
 
-from flock.core.context.context import FlockContext
-from flock.core.logging.logging import get_logger
-from flock.workflow.activities import run_agent
-
-# Import activity, passing it through the sandbox without reloading the module
+# Import activities from the new file
+with workflow.unsafe.imports_passed_through():
+    from flock.core.context.context import AgentDefinition, FlockContext
+    from flock.core.context.context_vars import FLOCK_CURRENT_AGENT
+    from flock.core.flock_router import HandOffRequest
+    from flock.core.logging.logging import get_logger
+    from flock.workflow.agent_execution_activity import (
+        determine_next_agent,
+        execute_single_agent,
+    )
+    from flock.workflow.temporal_config import (
+        TemporalActivityConfig,
+        TemporalRetryPolicyConfig,
+    )
 
 
 logger = get_logger("workflow")
@@ -14,45 +24,202 @@ logger = get_logger("workflow")
 
 @workflow.defn
 class FlockWorkflow:
-    def __init__(self) -> None:
-        self.context = None
+    # No need for __init__ storing context anymore if passed to run
 
     @workflow.run
-    async def run(self, context_dict: dict) -> dict:
-        self.context = FlockContext.from_dict(context_dict)
-        self.context.workflow_id = workflow.info().workflow_id
-        self.context.workflow_timestamp = workflow.info().start_time.strftime("%Y-%m-%d %H:%M:%S")
+    async def run(self, workflow_args: dict[str, Any]) -> dict:
+        # --- Workflow Initialization ---
+        # Arguments are packed into a single dictionary
+        context_dict = workflow_args["context_dict"]
+        default_retry_config_dict = workflow_args["default_retry_config_dict"]
+
+        # Deserialize context and default retry config
+        context = FlockContext.from_dict(context_dict)
+        default_retry_config = TemporalRetryPolicyConfig.model_validate(
+            default_retry_config_dict
+        )
+
+        context.workflow_id = workflow.info().workflow_id
+        context.workflow_timestamp = workflow.info().start_time.strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+
+        current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
+        final_result = None
+        previous_agent_name = (
+            None  # Keep track of the agent that called the current one
+        )
+
+        logger.info(
+            "Starting workflow execution",
+            workflow_id=context.workflow_id,
+            start_time=context.workflow_timestamp,
+            initial_agent=current_agent_name,
+        )
 
         try:
-            logger.info(
-                "Starting workflow execution",
-                timestamp=self.context.workflow_timestamp,
-            )
+            while current_agent_name:
+                logger.info(
+                    "Executing agent activity", agent=current_agent_name
+                )
 
-            result = await workflow.execute_activity(
-                run_agent,
-                self.context,
-                start_to_close_timeout=timedelta(minutes=5),
-            )
+                # --- Determine Activity Settings ---
+                agent_def: AgentDefinition | None = (
+                    context.get_agent_definition(current_agent_name)
+                )
+                agent_activity_config: TemporalActivityConfig | None = None
+                final_retry_config = (
+                    default_retry_config  # Start with the workflow default
+                )
+
+                if agent_def and agent_def.agent_data.get(
+                    "temporal_activity_config"
+                ):
+                    try:
+                        agent_activity_config = (
+                            TemporalActivityConfig.model_validate(
+                                agent_def.agent_data["temporal_activity_config"]
+                            )
+                        )
+                        logger.debug(
+                            f"Loaded agent-specific temporal config for {current_agent_name}"
+                        )
+                    except Exception as e:
+                        logger.warn(
+                            f"Failed to validate agent temporal config for {current_agent_name}: {e}. Using defaults."
+                        )
+
+                # Layering logic: Agent config overrides workflow default config
+                activity_task_queue = (
+                    workflow.info().task_queue
+                )  # Default to workflow task queue
+                activity_timeout = timedelta(
+                    minutes=5
+                )  # Fallback default timeout
+
+                if agent_activity_config:
+                    activity_task_queue = (
+                        agent_activity_config.task_queue or activity_task_queue
+                    )
+                    activity_timeout = (
+                        agent_activity_config.start_to_close_timeout
+                        or activity_timeout
+                    )
+                    if agent_activity_config.retry_policy:
+                        final_retry_config = agent_activity_config.retry_policy
+
+                # Convert config to actual Temporal object
+                final_retry_policy = final_retry_config.to_temporalio_policy()
+
+                logger.debug(
+                    f"Final activity settings for {current_agent_name}: "
+                    f"queue='{activity_task_queue}', timeout={activity_timeout}, "
+                    f"retries={final_retry_policy.maximum_attempts}"
+                )
 
-            self.context.set_variable(
+                # --- Execute the current agent activity ---
+                agent_result = await workflow.execute_activity(
+                    execute_single_agent,
+                    args=[current_agent_name, context],
+                    task_queue=activity_task_queue,  # Use determined task queue
+                    start_to_close_timeout=activity_timeout,  # Use determined timeout
+                    retry_policy=final_retry_policy,  # Use determined retry policy
+                )
+
+                # Record the execution in the context history
+                # Note: The 'called_from' is the agent *before* this one
+                context.record(
+                    agent_name=current_agent_name,
+                    data=agent_result,
+                    timestamp=workflow.now().isoformat(),  # Use deterministic workflow time
+                    hand_off=None,  # Will be updated if handoff occurs
+                    called_from=previous_agent_name,  # Pass the correct previous agent
+                )
+
+                final_result = agent_result  # Store the result of the last successful agent
+
+                logger.info(
+                    "Determining next agent activity",
+                    current_agent=current_agent_name,
+                )
+                # --- Determine the next agent activity (using workflow defaults for now) ---
+                # We could apply similar config logic to determine_next_agent if needed
+                handoff_data_dict = await workflow.execute_activity(
+                    determine_next_agent,
+                    args=[current_agent_name, agent_result, context],
+                    # Using sensible defaults, but could be configured via workflow_config?
+                    start_to_close_timeout=timedelta(minutes=1),
+                    retry_policy=default_retry_config.to_temporalio_policy(),  # Use default retry
+                )
+
+                # Update previous agent name for the next loop iteration
+                previous_agent_name = current_agent_name
+
+                if handoff_data_dict:
+                    logger.debug(
+                        "Handoff data received", data=handoff_data_dict
+                    )
+                    # Deserialize handoff data back into Pydantic model for easier access
+                    handoff_request = HandOffRequest.model_validate(
+                        handoff_data_dict
+                    )
+
+                    # Update context based on handoff overrides
+                    if handoff_request.override_context:
+                        context.state.update(handoff_request.override_context)
+                        logger.info("Context updated based on handoff override")
+
+                    # Update the last record's handoff information
+                    if context.history:
+                        context.history[-1].hand_off = handoff_data_dict
+
+                    # Set the next agent
+                    current_agent_name = handoff_request.next_agent
+                    if current_agent_name:
+                        context.set_variable(
+                            FLOCK_CURRENT_AGENT, current_agent_name
+                        )
+                        logger.info("Next agent set", agent=current_agent_name)
+                    else:
+                        logger.info(
+                            "Handoff requested termination (no next agent)"
+                        )
+                        break  # Exit loop if router explicitly returned no next agent
+
+                else:
+                    # No handoff data returned (no router or router returned None)
+                    logger.info("No handoff occurred, workflow terminating.")
+                    current_agent_name = None  # End the loop
+
+            # --- Workflow Completion ---
+            logger.success(
+                "Workflow completed successfully",
+                final_agent=previous_agent_name,
+            )
+            context.set_variable(
                 "flock.result",
                 {
-                    "result": result,
+                    "result": final_result,  # Return the last agent's result
                     "success": True,
                 },
             )
-
-            logger.success("Workflow completed successfully")
-            return result
+            return final_result  # Return the actual result of the last agent
 
         except Exception as e:
+            # Catch exceptions from activities (e.g., after retries fail)
+            # or workflow logic errors
             logger.exception("Workflow execution failed", error=str(e))
-            self.context.set_variable(
+            context.set_variable(
                 "flock.result",
                 {
-                    "result": f"Failed: {e}",
+                    "result": f"Workflow failed: {e}",
                     "success": False,
                 },
             )
-            return self.context
+            # It's often better to let Temporal record the failure status
+            # by re-raising the exception rather than returning a custom error dict.
+            # However, returning the context might be useful for debugging.
+            # Consider re-raising: raise
+            return context.model_dump(
+                mode="json"
+            )  # Return context state on failure

flock/workflow/temporal_config.py

@@ -0,0 +1,96 @@
+# src/flock/config/temporal_config.py
+
+"""Pydantic models for configuring Temporal execution settings."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import TYPE_CHECKING
+
+# Conditionally import for type hinting only
+if TYPE_CHECKING:
+    from temporalio.common import RetryPolicy
+
+# Note: Importing temporalio types directly into config models can complicate serialization
+# if these models are meant to be purely data containers (e.g., for YAML/JSON).
+# We define the structure and provide a helper method to convert to the actual Temporal object.
+# Be careful if using workflow/activity decorators directly on methods within these config models.
+from pydantic import BaseModel, Field
+
+
+class TemporalRetryPolicyConfig(BaseModel):
+    """Configuration parameters for Temporal Retry Policies."""
+
+    initial_interval: timedelta = Field(
+        default=timedelta(seconds=1),
+        description="Initial delay before the first retry.",
+    )
+    backoff_coefficient: float = Field(
+        default=2.0, description="Multiplier for the delay between retries."
+    )
+    maximum_interval: timedelta | None = Field(
+        default=timedelta(seconds=100),
+        description="Maximum delay between retries.",
+    )
+    maximum_attempts: int = Field(
+        default=3,
+        description="Maximum number of retry attempts (0 means no retries after first failure).",
+    )
+    non_retryable_error_types: list[str] = Field(
+        default_factory=list,
+        description="List of error type names (strings) that should not be retried.",
+    )
+
+    # Helper to convert to actual Temporalio object when needed (e.g., in workflow/executor)
+    def to_temporalio_policy(self) -> RetryPolicy:
+        # Import locally to avoid making temporalio a hard dependency of the config module itself
+        # The type hint RetryPolicy is now available due to TYPE_CHECKING block
+        from temporalio.common import RetryPolicy
+
+        return RetryPolicy(
+            initial_interval=self.initial_interval,
+            backoff_coefficient=self.backoff_coefficient,
+            maximum_interval=self.maximum_interval,
+            maximum_attempts=self.maximum_attempts,
+            non_retryable_error_types=self.non_retryable_error_types,
+        )
+
+
+class TemporalWorkflowConfig(BaseModel):
+    """Configuration specific to Temporal Workflow Execution for a Flock."""
+
+    task_queue: str = Field(
+        default="flock-queue",
+        description="Default task queue for the workflow execution.",
+    )
+    workflow_execution_timeout: timedelta | None = Field(
+        default=None,  # Default to no timeout (Temporal server default)
+        description="Total time limit for the workflow execution.",
+    )
+    workflow_run_timeout: timedelta | None = Field(
+        default=None,  # Default to no timeout (Temporal server default)
+        description="Time limit for a single workflow run attempt.",
+    )
+    # Default retry policy for activities if not specified per-agent
+    default_activity_retry_policy: TemporalRetryPolicyConfig = Field(
+        default_factory=TemporalRetryPolicyConfig,
+        description="Default retry policy applied to activities if not overridden by the agent.",
+    )
+
+
+class TemporalActivityConfig(BaseModel):
+    """Configuration specific to Temporal Activity Execution (per Agent)."""
+
+    task_queue: str | None = Field(
+        default=None,
+        description="Specific task queue for this agent's activity execution (overrides workflow default).",
+    )
+    start_to_close_timeout: timedelta | None = Field(
+        default=timedelta(minutes=5),  # Default to 5 minutes
+        description="Time limit for a single activity attempt.",
+    )
+    retry_policy: TemporalRetryPolicyConfig | None = Field(
+        default=None,
+        description="Specific retry policy for this activity (overrides workflow default).",
+    )
+    # Other timeouts like schedule_to_start, heartbeat_timeout could be added here if needed

flock/workflow/temporal_setup.py

@@ -1,5 +1,3 @@
-import asyncio
-import traceback
 import uuid
 
 from temporalio.client import Client
@@ -7,34 +5,33 @@ from temporalio.worker import Worker
 
 
 async def create_temporal_client() -> Client:
+    # Consider making the address configurable
     client = await Client.connect("localhost:7233")
     return client
 
 
-async def setup_worker(workflow, activity) -> Client:
-    """Setup the worker and return the result of the worker.run() call."""
-    try:
-        # debug
-        # print("workflow =", workflow)
-        # print("isclass     :", inspect.isclass(workflow))
-        # print(
-        #     "has _defn   :",
-        #     hasattr(workflow, "_temporalio_workflow_definition"),
-        # )
-        worker_client = await create_temporal_client()
-        worker = Worker(
-            worker_client,
-            task_queue="flock-queue",
-            workflows=[workflow],
-            activities=[activity],
-        )
-        result = asyncio.create_task(worker.run())
-        await asyncio.sleep(1)
-        return result
-    except Exception:
-        print("\n=== Worker construction failed ===")
-        traceback.print_exc()
-        raise
+async def setup_worker(
+    client: Client, task_queue: str, workflow: type, activities: list
+) -> Worker:
+    """Creates and configures a worker instance, but does not run it.
+
+    Args:
+        client: The Temporal client to associate with the worker.
+        task_queue: The task queue the worker should listen on.
+        workflow: The workflow class definition.
+        activities: A list of activity functions.
+
+    Returns:
+        A configured Worker instance.
+    """
+    # Creates and configures the worker instance
+    worker = Worker(
+        client,
+        task_queue=task_queue,
+        workflows=[workflow],
+        activities=activities,
+    )
+    return worker  # Return the configured worker instance
 
 
 async def run_worker(client: Client, task_queue: str, workflows, activities):

{flock_core-0.4.0b26.dist-info → flock_core-0.4.0b27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b26
+Version: 0.4.0b27
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -216,13 +216,39 @@ if __name__ == "__main__":
 
 ## 🐤 New in Flock 0.4.0 `Magpie` 🐤
 
-### REST API - Deploy Flock Agents as REST API Endpoints
+Version 0.4.0 brings significant enhancements focused on usability, deployment, and robustness:
 
-### Web UI - Test Flock Agents in the Browser
 
-### CLI Tool - Manage Flock Agents via the Command Line
+### 🚀 REST API - Deploy Flock Agents as REST API Endpoints
 
-### Serialization - Share, Deploy, and Run Flock Agents by human readable yaml files
+Easily deploy your Flock agents as scalable REST API endpoints. Interact with your agent workflows via standard HTTP requests.
+
+### 🖥️ Web UI - Test Flock Agents in the Browser
+
+Test and interact with your Flock agents directly in your browser through an integrated web interface.
+
+### ⌨️ CLI Tool - Manage Flock Agents via the Command Line
+
+Manage Flock configurations, run agents, and inspect results directly from your command line.
+
+### 💾 Enhanced Serialization - Share, Deploy, and Run Flock Agents by human readable yaml files
+
+Define and share entire Flock configurations, including agents and components, using human-readable YAML files. Load flocks directly from these files for easy deployment and versioning.
+
+### ⏱️ Robust Temporal Integration
+
+Flock 0.4.0 introduces first-class support for Temporal.io, enabling you to build truly production-grade, reliable, and scalable agent workflows. Move beyond simple local execution and leverage Temporal's power for:
+
+*   **Fault Tolerance:** Workflows automatically resume from the last successful step after failures.
+*   **Retries:** Configure automatic retries for activities (like LLM calls or tool usage) with exponential backoff.
+*   **Scalability:** Distribute workflow and activity execution across multiple worker processes using Task Queues.
+*   **Observability:** Gain deep insights into workflow execution history via the Temporal UI.
+
+Flock makes this easy with:
+
+*   **Declarative Configuration:** Define Temporal timeouts, retry policies, and task queues directly within your `Flock` and `FlockAgent` configurations (YAML or Python).
+*   **Correct Patterns:** Uses Temporal's recommended granular activity execution for better control and visibility.
+*   **Clear Worker Separation:** Provides guidance and flags for running dedicated Temporal workers, separating development convenience from production best practices.
 
 ### ✨ Utility: @flockclass Hydrator
 

{flock_core-0.4.0b26.dist-info → flock_core-0.4.0b27.dist-info}/RECORD

@@ -19,10 +19,10 @@ flock/cli/view_results.py,sha256=dOzK0O1FHSIDERnx48y-2Xke9BkOHS7pcOhs64AyIg0,781
 flock/cli/yaml_editor.py,sha256=K3N0bh61G1TSDAZDnurqW9e_-hO6CtSQKXQqlDhCjVo,12527
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=p7lmQULRu9ejIAELfanZiyMhW0CougIPvyFHW2nqBFQ,847
-flock/core/flock.py,sha256=eymHQ4BT-mVT-ml4Eod13iuS5-sAskDgOa83qwAyFos,25776
-flock/core/flock_agent.py,sha256=9hAkWUpxxz2nFamTENFhLBzAFOdIfLZTQuVcn68G1l0,38890
+flock/core/flock.py,sha256=_T_KAFePtEGDzfiFGV1HCdz7VHzj_U0cCquhAQ4xMAM,28199
+flock/core/flock_agent.py,sha256=oOMPw9fmZCAdqJXZsLTbjc4tdIq6gn5_nX3GvPgm61Q,38969
 flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
-flock/core/flock_factory.py,sha256=uRqcpu1fFbsDKp5YhGk47c6NjC36vAowQ3wzaQqmkBo,2972
+flock/core/flock_factory.py,sha256=_4zsjkEmJnCR7IvJ3SUHnDbX6c7Tt3E4P5ohxwKvE6w,3173
 flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
 flock/core/flock_registry.py,sha256=Qcu9juUFNyDAOEsqVxauwVlWdfgKZrSzc8yT8JMiK-c,24246
 flock/core/flock_router.py,sha256=1OAXDsdaIIFApEfo6SRfFEDoTuGt3Si7n2MXiySEfis,2644
@@ -35,14 +35,14 @@ flock/core/api/runner.py,sha256=PjKQyMNawHm_N-X2uTUWBKAKBe7AEzNmRIGwQI6tUWw,1156
 flock/core/api/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/core/api/ui/routes.py,sha256=nS-wWO94mshE5ozWfOQZ-HOvtes_1qxDVcqpMZtU5JQ,8885
 flock/core/api/ui/utils.py,sha256=V7PqYHNK519hFJ8jvvwf7bGpbBXCRz_HQG3BDCCqlNA,4802
-flock/core/context/context.py,sha256=8bjRLZ74oacRNBaHmDNXdQKfB-95poF7Pp03n2k0zcQ,6437
+flock/core/context/context.py,sha256=GFqMwYXLheqECGvWcxar7sQ2-GuY3RVynZ7kjwd65R0,6875
 flock/core/context/context_manager.py,sha256=FANSWa6DEhdhtZ7t_9Gza0v80UdpoDOhHbfVOccmjkA,1181
 flock/core/context/context_vars.py,sha256=ASPA29hpENWub4mgRoG62FtTVakCHQZfn6IhJQKe3C8,347
 flock/core/evaluation/utils.py,sha256=ZJkIMC9YT-HA2SPCZ4_bQ98isW1i6nbltVEYbjze-b0,12827
 flock/core/execution/batch_executor.py,sha256=nvsFOVaH4c4uPw_gwZ5jCIULpK59EL1kmcoPTja5kko,13745
 flock/core/execution/evaluation_executor.py,sha256=D9EO0sU-2qWj3vomjmUUi-DOtHNJNFRf30kGDHuzREE,17702
 flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjaygl_Db0M8ao,952
-flock/core/execution/temporal_executor.py,sha256=ZDTdTI13UKIAFQmBGA9fISDmDfHNsKJIjcKLOXEvhro,1949
+flock/core/execution/temporal_executor.py,sha256=dHcb0xuzPFWU_wbwTgI7glLNyyppei93Txs2sapjhaw,6283
 flock/core/interpreter/python_interpreter.py,sha256=RaUMZuufsKBNQ4FAeSaOgUuxzs8VYu5TgUUs-xwaxxM,26376
 flock/core/logging/__init__.py,sha256=Q8hp9-1ilPIUIV0jLgJ3_cP7COrea32cVwL7dicPnlM,82
 flock/core/logging/logging.py,sha256=JcgABQ8QJU1hhzhfF93eqnE0jhyXGZ2oObZst68sKR8,15409
@@ -440,10 +440,12 @@ flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolU
 flock/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/workflow/activities.py,sha256=Rcgcepa-RzaEjKo2aNuI14O_sX8ij0RrqeyPa0oSw8M,9910
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
-flock/workflow/flock_workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock/workflow/temporal_setup.py,sha256=epYMHdmTFC6njn3eaJOcs7E5yB0sxqHoMBvFeKSbKE8,1701
-flock_core-0.4.0b26.dist-info/METADATA,sha256=hX9OrCZRs6Neu4seUKingm6YggEYeTL9_aVcONqHreo,13004
-flock_core-0.4.0b26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.0b26.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.0b26.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.0b26.dist-info/RECORD,,
+flock/workflow/agent_execution_activity.py,sha256=Gy6FtuVAjf0NiUXmC3syS2eJpNQF4R3pmwMq47NYW3U,9462
+flock/workflow/flock_workflow.py,sha256=iSUF_soFvWar0ffpkzE4irkDZRx0p4HnwmEBi_Ne2sY,9666
+flock/workflow/temporal_config.py,sha256=3_8O7SDEjMsSMXsWJBfnb6XTp0TFaz39uyzSlMTSF_I,3988
+flock/workflow/temporal_setup.py,sha256=YIHnSBntzOchHfMSh8hoLeNXrz3B1UbR14YrR6soM7A,1606
+flock_core-0.4.0b27.dist-info/METADATA,sha256=N3xUdEq5nlLB7BVjw8gnEaGMsRKJDX5K7w5ogfS5RCw,14825
+flock_core-0.4.0b27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.0b27.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.0b27.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.0b27.dist-info/RECORD,,