flock-core 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

flock/__init__.py

@@ -1,8 +1 @@
 """Flock package initialization."""
-
-from opentelemetry import trace
-
-from flock.config import TELEMETRY
-
-tracer = TELEMETRY.setup_tracing()
-tracer = trace.get_tracer(__name__)

flock/config.py

@@ -28,9 +28,9 @@ JAEGER_TRANSPORT = config(
 ).lower()  # Options: "grpc" or "http"
 OTEL_SQL_DATABASE_NAME = config("OTEL_SQL_DATABASE", "flock_events.db")
 OTEL_FILE_NAME = config("OTEL_FILE_NAME", "flock_events.jsonl")
-OTEL_ENABLE_SQL = config("OTEL_ENABLE_SQL", True)
-OTEL_ENABLE_FILE = config("OTEL_ENABLE_FILE", True)
-OTEL_ENABLE_JAEGER = config("OTEL_ENABLE_JAEGER", True)
+OTEL_ENABLE_SQL: bool = config("OTEL_ENABLE_SQL", True) == "True"
+OTEL_ENABLE_FILE: bool = config("OTEL_ENABLE_FILE", True) == "True"
+OTEL_ENABLE_JAEGER: bool = config("OTEL_ENABLE_JAEGER", True) == "True"
 
 
 TELEMETRY = TelemetryConfig(

flock/core/flock.py

@@ -40,6 +40,7 @@ class Flock:
         output_formatter: FormatterOptions = FormatterOptions(
             PrettyPrintFormatter
         ),
+        show_cli_banner: bool = True,
     ):
         """Initialize the Flock orchestrator.
 
@@ -66,10 +67,10 @@ class Flock:
             session_id = get_baggage("session_id")
             if not session_id:
                 session_id = str(uuid.uuid4())
-            set_baggage("session_id", session_id)
-            span.set_attribute("session_id", get_baggage("session_id"))
+                set_baggage("session_id", session_id)
 
-            display_banner()
+            if show_cli_banner:
+                display_banner()
 
             self.agents: dict[str, FlockAgent] = {}
             self.registry = Registry()

flock/core/flock_agent.py

@@ -151,7 +151,7 @@ class FlockAgent(BaseModel, ABC, PromptParserMixin, DSPyIntegrationMixin):
         ),
     )
 
-    tools: list[Callable[..., Any]] | None = Field(
+    tools: list[Callable[..., Any] | Any] | None = Field(
         default=None,
         description="An optional list of callable tools that the agent can leverage during execution.",
     )

flock/core/logging/formatters/pprint_formatter.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any
 
 from flock.core.logging.formatters.base_formatter import BaseFormatter
@@ -9,16 +8,18 @@ class PrettyPrintFormatter(BaseFormatter):
         self, result: dict[str, Any], agent_name: str, **kwargs
     ) -> None:
         """Print an agent's result using Rich formatting."""
+        from devtools import pformat
         from rich.console import Console
-        from rich.json import JSON
+        from rich.panel import Panel
 
         console = Console()
 
-        console.print(agent_name)
-        console.print(JSON(json.dumps(result)))
+        s = pformat(result, highlight=False)
+
+        console.print(Panel(s, title=agent_name, highlight=True))
 
     def display_data(self, data: dict[str, Any], **kwargs) -> None:
         """Print an agent's result using Rich formatting."""
-        from devtools import pprint
+        from devtools import sprint
 
-        pprint(data)
+        sprint(data, sprint.green)

flock/core/mixin/dspy_integration.py

@@ -1,10 +1,11 @@
 """Mixin class for integrating with the dspy library."""
 
+import inspect
 import sys
 from typing import Any, Literal
 
 from flock.core.logging.logging import get_logger
-from flock.core.util.input_resolver import split_top_level
+from flock.core.util.input_resolver import get_callable_members, split_top_level
 
 logger = get_logger("flock")
 
@@ -68,15 +69,19 @@ class DSPyIntegrationMixin:
                 # TODO: We have to find a way to avoid using eval here.
                 # This is a security risk, as it allows arbitrary code execution.
 
-                try:
-                    field_type = eval(type_str, sys.modules[__name__].__dict__)
-                except Exception:
-                    field_type = eval(
-                        type_str, sys.modules["__main__"].__dict__
-                    )
+                field_type = dspy.PythonInterpreter(
+                    sys.modules[__name__].__dict__
+                    | sys.modules["__main__"].__dict__
+                ).execute(type_str)
+
+                # try:
+                #     field_type = eval(type_str, sys.modules[__name__].__dict__)
+                # except Exception:
+                #     field_type = eval(
+                #         type_str, sys.modules["__main__"].__dict__
+                #     )
 
             except Exception:
-                # If evaluation fails, default to str.
                 field_type = str
 
             return name, field_type, desc
@@ -143,6 +148,14 @@ class DSPyIntegrationMixin:
         """
         import dspy
 
+        processed_tools = []
+        if self.tools:
+            for tool in self.tools:
+                if inspect.ismodule(tool) or inspect.isclass(tool):
+                    processed_tools.extend(get_callable_members(tool))
+                else:
+                    processed_tools.append(tool)
+
         dspy_solver = None
 
         if agent_type_override:
@@ -153,7 +166,7 @@ class DSPyIntegrationMixin:
             if agent_type_override == "ReAct":
                 dspy.ReAct(
                     signature,
-                    tools=self.tools,
+                    tools=processed_tools,
                     max_iters=10,
                 )
             if agent_type_override == "Completion":
@@ -164,7 +177,7 @@ class DSPyIntegrationMixin:
             if self.tools:
                 dspy_solver = dspy.ReAct(
                     signature,
-                    tools=self.tools,
+                    tools=processed_tools,
                     max_iters=10,
                 )
             else:

flock/core/tools/basic_tools.py

@@ -2,29 +2,14 @@
 
 import importlib
 import os
+from typing import Literal
 
 from flock.core.logging.trace_and_logged import traced_and_logged
+from flock.interpreter.python_interpreter import PythonInterpreter
 
 
 @traced_and_logged
 def web_search_tavily(query: str):
-    """Performs a web search using the Tavily client.
-
-    This function checks if the optional 'tavily' dependency is installed. If so,
-    it creates a TavilyClient using the API key from the environment variable
-    'TAVILY_API_KEY' and performs a search with the provided query. The search response
-    is returned if successful.
-
-    Parameters:
-        query (str): The search query string.
-
-    Returns:
-        Any: The search response obtained from the Tavily client.
-
-    Raises:
-        ImportError: If the 'tavily' dependency is not installed.
-        Exception: Re-raises any exceptions encountered during the search.
-    """
     if importlib.util.find_spec("tavily") is not None:
         from tavily import TavilyClient
 
@@ -41,22 +26,24 @@ def web_search_tavily(query: str):
 
 
 @traced_and_logged
-def get_web_content_as_markdown(url: str):
-    """Fetches web content from a URL and converts it to Markdown.
+def web_search_duckduckgo(
+    keywords: str, search_type: Literal["news", "web"] = "web"
+):
+    try:
+        from duckduckgo_search import DDGS
 
-    This function uses the 'httpx' library to retrieve the content of the provided URL.
-    It then converts the HTML content into Markdown using the 'markdownify' library.
+        if search_type == "news":
+            response = DDGS().news(keywords)
+        else:
+            response = DDGS().text(keywords)
 
-    Parameters:
-        url (str): The URL of the web page to fetch.
+        return response
+    except Exception:
+        raise
 
-    Returns:
-        str: The web page content converted into Markdown format.
 
-    Raises:
-        ImportError: If either 'httpx' or 'markdownify' dependencies are not installed.
-        Exception: Re-raises any exceptions encountered during the HTTP request or conversion.
-    """
+@traced_and_logged
+def get_web_content_as_markdown(url: str):
     if (
         importlib.util.find_spec("httpx") is not None
         and importlib.util.find_spec("markdownify") is not None
@@ -79,22 +66,6 @@ def get_web_content_as_markdown(url: str):
 
 @traced_and_logged
 def get_anything_as_markdown(url_or_file_path: str):
-    """Converts the content of a URL or file into Markdown format.
-
-    This function leverages the 'docling' library to convert various document types
-    (retrieved from a URL or a local file) into Markdown. It uses the DocumentConverter
-    from the 'docling.document_converter' module.
-
-    Parameters:
-        url_or_file_path (str): The URL or local file path of the document to convert.
-
-    Returns:
-        str: The converted document in Markdown format.
-
-    Raises:
-        ImportError: If the 'docling' dependency is not installed.
-        Exception: Re-raises any exceptions encountered during the document conversion.
-    """
     if importlib.util.find_spec("docling") is not None:
         from docling.document_converter import DocumentConverter
 
@@ -113,49 +84,53 @@ def get_anything_as_markdown(url_or_file_path: str):
 
 @traced_and_logged
 def evaluate_math(expression: str) -> float:
-    """Evaluates a mathematical expression using the dspy interpreter.
-
-    This function uses the 'dspy' library's PythonInterpreter to evaluate the provided
-    mathematical expression.
-
-    Parameters:
-        expression (str): A string containing the mathematical expression to evaluate.
-
-    Returns:
-        float: The result of the evaluated expression.
-
-    Raises:
-        Exception: Re-raises any exceptions encountered during the evaluation.
-    """
-    import dspy
-
     try:
-        result = dspy.PythonInterpreter({}).execute(expression)
+        result = PythonInterpreter(
+            {},
+            [
+                "os",
+                "math",
+                "random",
+                "datetime",
+                "time",
+                "string",
+                "collections",
+                "itertools",
+                "functools",
+                "typing",
+                "enum",
+                "json",
+                "ast",
+            ],
+            verbose=True,
+        ).execute(expression)
         return result
     except Exception:
         raise
 
 
 @traced_and_logged
-def code_eval(python_code: str) -> float:
-    """Executes Python code using the dspy interpreter.
-
-    This function takes a string of Python code, executes it using the 'dspy' PythonInterpreter,
-    and returns the result.
-
-    Parameters:
-        python_code (str): A string containing Python code to execute.
-
-    Returns:
-        float: The result of the executed code.
-
-    Raises:
-        Exception: Re-raises any exceptions encountered during code execution.
-    """
-    import dspy
-
+def code_eval(python_code: str) -> str:
     try:
-        result = dspy.PythonInterpreter({}).execute(python_code)
+        result = PythonInterpreter(
+            {},
+            [
+                "os",
+                "math",
+                "random",
+                "datetime",
+                "time",
+                "string",
+                "collections",
+                "itertools",
+                "functools",
+                "typing",
+                "enum",
+                "json",
+                "ast",
+            ],
+            verbose=True,
+        ).execute(python_code)
         return result
     except Exception:
         raise
@@ -163,11 +138,6 @@ def code_eval(python_code: str) -> float:
 
 @traced_and_logged
 def get_current_time() -> str:
-    """Retrieves the current time in ISO 8601 format.
-
-    Returns:
-        str: The current date and time as an ISO 8601 formatted string.
-    """
     import datetime
 
     time = datetime.datetime.now().isoformat()
@@ -176,33 +146,12 @@ def get_current_time() -> str:
 
 @traced_and_logged
 def count_words(text: str) -> int:
-    """Counts the number of words in the provided text.
-
-    This function splits the input text by whitespace and returns the count of resulting words.
-
-    Parameters:
-        text (str): The text in which to count words.
-
-    Returns:
-        int: The number of words in the text.
-    """
     count = len(text.split())
     return count
 
 
 @traced_and_logged
 def extract_urls(text: str) -> list[str]:
-    """Extracts all URLs from the given text.
-
-    This function uses a regular expression to find all substrings that match the typical
-    URL pattern (starting with http or https).
-
-    Parameters:
-        text (str): The text from which to extract URLs.
-
-    Returns:
-        list[str]: A list of URLs found in the text.
-    """
     import re
 
     url_pattern = r"https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+"
@@ -212,17 +161,6 @@ def extract_urls(text: str) -> list[str]:
 
 @traced_and_logged
 def extract_numbers(text: str) -> list[float]:
-    """Extracts all numerical values from the provided text.
-
-    This function uses a regular expression to find substrings that represent integers or decimals,
-    converts them to floats, and returns them as a list.
-
-    Parameters:
-        text (str): The text from which to extract numerical values.
-
-    Returns:
-        list[float]: A list of numbers (as floats) found in the text.
-    """
     import re
 
     numbers = [float(x) for x in re.findall(r"-?\d*\.?\d+", text)]
@@ -231,17 +169,6 @@ def extract_numbers(text: str) -> list[float]:
 
 @traced_and_logged
 def json_parse_safe(text: str) -> dict:
-    """Safely parses a JSON string into a dictionary.
-
-    This function attempts to load a JSON object from the given text. If parsing fails,
-    it returns an empty dictionary instead of raising an exception.
-
-    Parameters:
-        text (str): The JSON-formatted string to parse.
-
-    Returns:
-        dict: The parsed JSON object as a dictionary, or an empty dictionary if parsing fails.
-    """
     import json
 
     try:
@@ -253,18 +180,6 @@ def json_parse_safe(text: str) -> dict:
 
 @traced_and_logged
 def save_to_file(content: str, filename: str):
-    """Saves the given content to a file.
-
-    This function writes the provided content to a file specified by the filename.
-    If the file cannot be written, an exception is raised.
-
-    Parameters:
-        content (str): The content to be saved.
-        filename (str): The path to the file where the content will be saved.
-
-    Raises:
-        Exception: Re-raises any exceptions encountered during the file write operation.
-    """
     try:
         with open(filename, "w") as f:
             f.write(content)
@@ -274,20 +189,6 @@ def save_to_file(content: str, filename: str):
 
 @traced_and_logged
 def read_from_file(filename: str) -> str:
-    """Reads and returns the content of a file.
-
-    This function opens the specified file, reads its content, and returns it as a string.
-    If the file cannot be read, an exception is raised.
-
-    Parameters:
-        filename (str): The path to the file to be read.
-
-    Returns:
-        str: The content of the file.
-
-    Raises:
-        Exception: Re-raises any exceptions encountered during the file read operation.
-    """
     try:
         with open(filename) as f:
             content = f.read()

flock/core/tools/dev_tools/github.py

@@ -10,23 +10,6 @@ from flock.core.logging.trace_and_logged import traced_and_logged
 
 @traced_and_logged
 def create_user_stories_as_github_issue(title: str, body: str) -> str:
-    """Create a new GitHub issue representing a user story.
-
-    This function creates an issue in a GitHub repository using the specified title and body.
-    The title is used as the issue title, and the body should contain the full user story
-    description along with a formatted list of acceptance criteria. The following
-    environment variables must be set for this function to work correctly:
-
-      - GITHUB_PAT: Personal Access Token for GitHub API authentication.
-      - GITHUB_REPO: Repository identifier in the format "owner/repo".
-
-    Parameters:
-        title (str): The title for the GitHub issue (user story).
-        body (str): The detailed description including acceptance criteria.
-
-    Returns:
-        str: A message indicating whether the issue was created successfully or not.
-    """
     github_pat = os.getenv("GITHUB_PAT")
     github_repo = os.getenv("GITHUB_REPO")
 
@@ -49,22 +32,6 @@ def create_user_stories_as_github_issue(title: str, body: str) -> str:
 
 @traced_and_logged
 def upload_readme(content: str):
-    """Upload or update the README.md file in a GitHub repository.
-
-    This function uses the GitHub API to either create a new README.md file or update an
-    existing one in the specified repository. It encodes the provided content to base64 before
-    sending it via the API. The function requires the following environment variables to be set:
-
-      - GITHUB_USERNAME: Your GitHub username.
-      - GITHUB_REPO: The name of the repository.
-      - GITHUB_PAT: Your GitHub Personal Access Token for authentication.
-
-    Parameters:
-        content (str): The text content to be written into the README.md file.
-
-    Raises:
-        ValueError: If any of the required environment variables are missing.
-    """
     GITHUB_USERNAME = os.getenv("GITHUB_USERNAME")
     REPO_NAME = os.getenv("GITHUB_REPO")
     GITHUB_TOKEN = os.getenv("GITHUB_PAT")

flock/core/util/input_resolver.py

@@ -3,6 +3,25 @@
 from flock.core.context.context import FlockContext
 
 
+def get_callable_members(obj):
+    """Extract all callable (methods/functions) members from a module or class.
+    Returns a list of callable objects.
+    """
+    import inspect
+
+    # Get all members of the object
+    members = inspect.getmembers(obj)
+
+    # Filter for callable members that don't start with underscore (to exclude private/special methods)
+    callables = [
+        member[1]
+        for member in members
+        if inspect.isroutine(member[1]) and not member[0].startswith("_")
+    ]
+
+    return callables
+
+
 def split_top_level(s: str) -> list[str]:
     """Split a string on commas that are not enclosed within brackets, parentheses, or quotes.
 

flock/interpreter/python_interpreter.py

@@ -0,0 +1,675 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+import ast
+import builtins
+import difflib
+import importlib
+import re
+import typing
+from collections.abc import Mapping
+from typing import (
+    Any,
+)
+
+
+class InterpreterError(ValueError):
+    r"""An error raised when the interpreter cannot evaluate a Python
+    expression, due to syntax error or unsupported operations.
+    """
+
+    pass
+
+
+class PythonInterpreter:
+    r"""A customized python interpreter to control the execution of
+    LLM-generated codes. The interpreter makes sure the code can only execute
+    functions given in action space and import white list. It also supports
+    fuzzy variable matching to receive uncertain input variable name.
+
+    [Documentation omitted for brevity]
+
+    Args:
+        action_space (Dict[str, Any]): A dictionary mapping action names to
+            their corresponding functions or objects.
+        import_white_list (Optional[List[str]], optional): A list of allowed modules.
+        verbose (bool, optional): If True, the interpreter prints log messages
+            as it executes the code. (default: False)
+    """
+
+    def __init__(
+        self,
+        action_space: dict[str, Any],
+        import_white_list: list[str] | None = None,
+        verbose: bool = False,
+    ) -> None:
+        self.action_space = action_space
+        self.state = self.action_space.copy()
+        self.fuzz_state: dict[str, Any] = {}
+        self.import_white_list = import_white_list or [
+            "math",
+            "random",
+            "datetime",
+            "time",
+            "string",
+            "collections",
+            "itertools",
+            "functools",
+            "typing",
+            "enum",
+            "json",
+            "ast",
+        ]  # default imports
+        self.verbose = verbose
+
+    def log(self, message: str) -> None:
+        """Print a log message immediately."""
+        print(message, flush=True)
+
+    def execute(
+        self,
+        code: str,
+        state: dict[str, Any] | None = None,
+        fuzz_state: dict[str, Any] | None = None,
+        keep_state: bool = True,
+    ) -> Any:
+        r"""Execute the input python codes in a secure environment.
+
+        [Documentation omitted for brevity]
+        """
+        if state is not None:
+            self.state.update(state)
+        if fuzz_state is not None:
+            self.fuzz_state.update(fuzz_state)
+
+        try:
+            expression = ast.parse(code)
+        except SyntaxError as e:
+            error_line = code.splitlines()[e.lineno - 1]
+            raise InterpreterError(
+                f"Syntax error in code at line {e.lineno}: {error_line}\nError: {e}"
+            )
+
+        result = None
+        if self.verbose:
+            self.log("[Interpreter] Starting code execution...")
+
+        for idx, node in enumerate(expression.body):
+            # Log the AST node being executed (using unparse if available)
+            if self.verbose:
+                try:
+                    node_repr = ast.unparse(node)
+                except Exception:
+                    node_repr = ast.dump(node)
+                self.log(f"[Interpreter] Executing node {idx}: {node_repr}")
+
+            try:
+                line_result = self._execute_ast(node)
+            except InterpreterError as e:
+                if not keep_state:
+                    self.clear_state()
+                msg = f"Evaluation of the code stopped at node {idx}. See:\n{e}"
+                raise InterpreterError(msg)
+            if line_result is not None:
+                result = line_result
+                if self.verbose:
+                    self.log(f"[Interpreter] Node {idx} result: {result}")
+
+        if self.verbose:
+            self.log("[Interpreter] Finished code execution.")
+        if not keep_state:
+            self.clear_state()
+
+        return result
+
+    def clear_state(self) -> None:
+        r"""Initialize :obj:`state` and :obj:`fuzz_state`"""
+        self.state = self.action_space.copy()
+        self.fuzz_state = {}
+
+    # ast.Index is deprecated after python 3.9, which cannot pass type check,
+    # but is still necessary for older versions.
+    @typing.no_type_check
+    def _execute_ast(self, expression: ast.AST) -> Any:
+        if isinstance(expression, ast.Assign):
+            return self._execute_assign(expression)
+        elif isinstance(expression, ast.Attribute):
+            value = self._execute_ast(expression.value)
+            return getattr(value, expression.attr)
+        elif isinstance(expression, ast.AugAssign):
+            return self._execute_augassign(expression)
+        elif isinstance(expression, ast.BinOp):
+            return self._execute_binop(expression)
+        elif isinstance(expression, ast.BoolOp):
+            return self._execute_condition(expression)
+        elif isinstance(expression, ast.Call):
+            return self._execute_call(expression)
+        elif isinstance(expression, ast.Compare):
+            return self._execute_condition(expression)
+        elif isinstance(expression, ast.Constant):
+            return expression.value
+        elif isinstance(expression, ast.Dict):
+            result: dict = {}
+            for k, v in zip(expression.keys, expression.values):
+                if k is not None:
+                    result[self._execute_ast(k)] = self._execute_ast(v)
+                else:
+                    result.update(self._execute_ast(v))
+            return result
+        elif isinstance(expression, ast.Expr):
+            return self._execute_ast(expression.value)
+        elif isinstance(expression, ast.For):
+            return self._execute_for(expression)
+        elif isinstance(expression, ast.FormattedValue):
+            return self._execute_ast(expression.value)
+        elif isinstance(expression, ast.FunctionDef):
+            self.state[expression.name] = expression
+            return None
+        elif isinstance(expression, ast.GeneratorExp):
+            return self._execute_generatorexp(expression)
+        elif isinstance(expression, ast.If):
+            return self._execute_if(expression)
+        elif isinstance(expression, ast.IfExp):
+            return self._execute_ifexp(expression)
+        elif isinstance(expression, ast.Import):
+            self._execute_import(expression)
+            return None
+        elif isinstance(expression, ast.ImportFrom):
+            self._execute_import_from(expression)
+            return None
+        elif hasattr(ast, "Index") and isinstance(expression, ast.Index):
+            return self._execute_ast(expression.value)
+        elif isinstance(expression, ast.JoinedStr):
+            return "".join(
+                [str(self._execute_ast(v)) for v in expression.values]
+            )
+        elif isinstance(expression, ast.Lambda):
+            return self._execute_lambda(expression)
+        elif isinstance(expression, ast.List):
+            return [self._execute_ast(elt) for elt in expression.elts]
+        elif isinstance(expression, ast.Name):
+            return self._execute_name(expression)
+        elif isinstance(expression, ast.Return):
+            return self._execute_ast(expression.value)
+        elif isinstance(expression, ast.Subscript):
+            return self._execute_subscript(expression)
+        elif isinstance(expression, ast.Tuple):
+            return tuple([self._execute_ast(elt) for elt in expression.elts])
+        elif isinstance(expression, ast.UnaryOp):
+            return self._execute_unaryop(expression)
+        elif isinstance(expression, ast.While):
+            return self._execute_while(expression)
+        elif isinstance(expression, ast.ListComp):
+            return self._execute_listcomp(expression)
+        elif isinstance(expression, ast.DictComp):
+            return self._execute_dictcomp(expression)
+        elif isinstance(expression, ast.SetComp):
+            return self._execute_setcomp(expression)
+        elif isinstance(expression, ast.Break):
+            raise BreakException()
+        elif isinstance(expression, ast.Continue):
+            raise ContinueException()
+        elif isinstance(expression, ast.Try):
+            return self._execute_try(expression)
+        elif isinstance(expression, ast.Raise):
+            return self._execute_raise(expression)
+        elif isinstance(expression, ast.Pass):
+            return None
+        elif isinstance(expression, ast.Assert):
+            return self._execute_assert(expression)
+        else:
+            raise InterpreterError(
+                f"{expression.__class__.__name__} is not supported."
+            )
+
+    def _execute_assign(self, assign: ast.Assign) -> Any:
+        targets = assign.targets
+        result = self._execute_ast(assign.value)
+
+        for target in targets:
+            self._assign(target, result)
+        return result
+
+    def _assign(self, target: ast.expr, value: Any):
+        if isinstance(target, ast.Name):
+            self.state[target.id] = value
+        elif isinstance(target, ast.Tuple):
+            if not isinstance(value, tuple):
+                raise InterpreterError(
+                    f"Expected type tuple, but got {value.__class__.__name__} instead."
+                )
+            if len(target.elts) != len(value):
+                raise InterpreterError(
+                    f"Expected {len(target.elts)} values but got {len(value)}."
+                )
+            for t, v in zip(target.elts, value):
+                self.state[self._execute_ast(t)] = v
+        else:
+            raise InterpreterError(
+                f"Unsupported variable type. Expected ast.Name or ast.Tuple, got {target.__class__.__name__} instead."
+            )
+
+    def _execute_call(self, call: ast.Call) -> Any:
+        callable_func = self._execute_ast(call.func)
+
+        args = [self._execute_ast(arg) for arg in call.args]
+        kwargs = {
+            keyword.arg: self._execute_ast(keyword.value)
+            for keyword in call.keywords
+        }
+        if isinstance(callable_func, ast.FunctionDef):
+            old_state = self.state.copy()
+            for param_name, arg_value in zip(
+                [param.arg for param in callable_func.args.args], args
+            ):
+                self.state[param_name] = arg_value
+            result = None
+            for stmt in callable_func.body:
+                result = self._execute_ast(stmt)
+                if isinstance(stmt, ast.Return):
+                    break
+            self.state = old_state
+            return result
+        return callable_func(*args, **kwargs)
+
+    def _execute_augassign(self, augassign: ast.AugAssign):
+        current_value = self.state[augassign.target.id]
+        increment_value = self._execute_ast(augassign.value)
+        if not (
+            isinstance(current_value, (int, float))
+            and isinstance(increment_value, (int, float))
+        ):
+            raise InterpreterError(
+                f"Invalid types for augmented assignment: {type(current_value)}, {type(increment_value)}"
+            )
+        if isinstance(augassign.op, ast.Add):
+            new_value = current_value + increment_value
+        elif isinstance(augassign.op, ast.Sub):
+            new_value = current_value - increment_value
+        elif isinstance(augassign.op, ast.Mult):
+            new_value = current_value * increment_value
+        elif isinstance(augassign.op, ast.Div):
+            new_value = current_value / increment_value
+        else:
+            raise InterpreterError(
+                f"Augmented assignment operator {augassign.op} is not supported"
+            )
+        self._assign(augassign.target, new_value)
+        return new_value
+
+    def _execute_subscript(self, subscript: ast.Subscript):
+        index = self._execute_ast(subscript.slice)
+        value = self._execute_ast(subscript.value)
+        if not isinstance(subscript.ctx, ast.Load):
+            raise InterpreterError(
+                f"{subscript.ctx.__class__.__name__} is not supported for subscript."
+            )
+        if isinstance(value, (list, tuple)):
+            return value[int(index)]
+        if index in value:
+            return value[index]
+        if isinstance(index, str) and isinstance(value, Mapping):
+            close_matches = difflib.get_close_matches(index, list(value.keys()))
+            if len(close_matches) > 0:
+                return value[close_matches[0]]
+        raise InterpreterError(f"Could not index {value} with '{index}'.")
+
+    def _execute_name(self, name: ast.Name):
+        if name.id in dir(builtins):
+            return getattr(builtins, name.id)
+        if isinstance(name.ctx, ast.Store):
+            return name.id
+        elif isinstance(name.ctx, ast.Load):
+            return self._get_value_from_state(name.id)
+        else:
+            raise InterpreterError(f"{name.ctx} is not supported.")
+
+    def _execute_condition(self, condition):
+        if isinstance(condition, ast.BoolOp):
+            if isinstance(condition.op, ast.And):
+                results = [
+                    self._execute_ast(value) for value in condition.values
+                ]
+                return all(results)
+            elif isinstance(condition.op, ast.Or):
+                results = [
+                    self._execute_ast(value) for value in condition.values
+                ]
+                return any(results)
+            else:
+                raise InterpreterError(
+                    f"Boolean operator {condition.op} is not supported"
+                )
+        elif isinstance(condition, ast.Compare):
+            if len(condition.ops) > 1:
+                raise InterpreterError(
+                    "Cannot evaluate conditions with multiple operators"
+                )
+            left = self._execute_ast(condition.left)
+            comparator = condition.ops[0]
+            right = self._execute_ast(condition.comparators[0])
+            if isinstance(comparator, ast.Eq):
+                return left == right
+            elif isinstance(comparator, ast.NotEq):
+                return left != right
+            elif isinstance(comparator, ast.Lt):
+                return left < right
+            elif isinstance(comparator, ast.LtE):
+                return left <= right
+            elif isinstance(comparator, ast.Gt):
+                return left > right
+            elif isinstance(comparator, ast.GtE):
+                return left >= right
+            elif isinstance(comparator, ast.Is):
+                return left is right
+            elif isinstance(comparator, ast.IsNot):
+                return left is not right
+            elif isinstance(comparator, ast.In):
+                return left in right
+            elif isinstance(comparator, ast.NotIn):
+                return left not in right
+            else:
+                raise InterpreterError("Unsupported comparison operator")
+        elif isinstance(condition, ast.UnaryOp):
+            return self._execute_unaryop(condition)
+        elif isinstance(condition, ast.Name) or isinstance(condition, ast.Call):
+            return bool(self._execute_ast(condition))
+        elif isinstance(condition, ast.Constant):
+            return bool(condition.value)
+        else:
+            raise InterpreterError(
+                f"Unsupported condition type: {type(condition).__name__}"
+            )
+
+    def _execute_if(self, if_statement: ast.If):
+        result = None
+        if self._execute_condition(if_statement.test):
+            for line in if_statement.body:
+                line_result = self._execute_ast(line)
+                if line_result is not None:
+                    result = line_result
+        else:
+            for line in if_statement.orelse:
+                line_result = self._execute_ast(line)
+                if line_result is not None:
+                    result = line_result
+        return result
+
+    def _execute_ifexp(self, ifexp: ast.IfExp) -> Any:
+        test_result = self._execute_condition(ifexp.test)
+        if test_result:
+            return self._execute_ast(ifexp.body)
+        else:
+            return self._execute_ast(ifexp.orelse)
+
+    def _execute_import(self, import_module: ast.Import) -> None:
+        for module in import_module.names:
+            self._validate_import(module.name)
+            alias = module.asname or module.name
+            self.state[alias] = importlib.import_module(module.name)
+
+    def _execute_import_from(self, import_from: ast.ImportFrom):
+        if import_from.module is None:
+            raise InterpreterError('"from . import" is not supported.')
+        for import_name in import_from.names:
+            full_name = import_from.module + f".{import_name.name}"
+            self._validate_import(full_name)
+            imported_module = importlib.import_module(import_from.module)
+            alias = import_name.asname or import_name.name
+            self.state[alias] = getattr(imported_module, import_name.name)
+
+    # Note: Two versions of _execute_for and _execute_while appear in this file.
+    # We keep both as provided, but you may wish to consolidate these in your code.
+
+    def _execute_for(self, for_statement: ast.For):
+        class BreakException(Exception):
+            pass
+
+        class ContinueException(Exception):
+            pass
+
+        result = None
+        try:
+            for value in self._execute_ast(for_statement.iter):
+                self._assign(for_statement.target, value)
+                try:
+                    for line in for_statement.body:
+                        line_result = self._execute_ast(line)
+                        if line_result is not None:
+                            result = line_result
+                except ContinueException:
+                    continue
+        except BreakException:
+            pass
+        return result
+
+    def _execute_while(self, while_statement: ast.While):
+        class BreakException(Exception):
+            pass
+
+        class ContinueException(Exception):
+            pass
+
+        result = None
+        try:
+            while self._execute_condition(while_statement.test):
+                try:
+                    for line in while_statement.body:
+                        line_result = self._execute_ast(line)
+                        if line_result is not None:
+                            result = line_result
+                except ContinueException:
+                    continue
+        except BreakException:
+            pass
+        return result
+
+    def _execute_try(self, try_statement: ast.Try):
+        try:
+            for line in try_statement.body:
+                self._execute_ast(line)
+        except Exception as e:
+            handled = False
+            for handler in try_statement.handlers:
+                if handler.type is None or isinstance(
+                    e, self._execute_ast(handler.type)
+                ):
+                    if handler.name:
+                        self.state[handler.name.id] = e
+                    for line in handler.body:
+                        self._execute_ast(line)
+                    handled = True
+                    break
+            if not handled:
+                raise
+        finally:
+            for line in try_statement.finalbody:
+                self._execute_ast(line)
+
+    def _execute_raise(self, raise_statement: ast.Raise):
+        if raise_statement.exc:
+            exception = self._execute_ast(raise_statement.exc)
+            raise exception
+        else:
+            raise
+
+    def _execute_assert(self, assert_statement: ast.Assert):
+        test_result = self._execute_condition(assert_statement.test)
+        if not test_result:
+            if assert_statement.msg:
+                msg = self._execute_ast(assert_statement.msg)
+                raise AssertionError(msg)
+            else:
+                raise AssertionError
+
+    def _execute_lambda(self, lambda_node: ast.Lambda) -> Any:
+        def lambda_function(*args):
+            old_state = self.state.copy()
+            for param, arg in zip(lambda_node.args.args, args):
+                self.state[param.arg] = arg
+            result = self._execute_ast(lambda_node.body)
+            self.state = old_state  # Restore the state
+            return result
+
+        return lambda_function
+
+    def _validate_import(self, full_name: str):
+        tmp_name = ""
+        found_name = False
+        for name in full_name.split("."):
+            tmp_name += name if tmp_name == "" else f".{name}"
+            if tmp_name in self.import_white_list:
+                found_name = True
+                return
+        if not found_name:
+            raise InterpreterError(
+                f"It is not permitted to import modules "
+                f"than module white list (try to import {full_name})."
+            )
+
+    def _execute_binop(self, binop: ast.BinOp):
+        left = self._execute_ast(binop.left)
+        operator = binop.op
+        right = self._execute_ast(binop.right)
+
+        if isinstance(operator, ast.Add):
+            return left + right
+        elif isinstance(operator, ast.Sub):
+            return left - right
+        elif isinstance(operator, ast.Mult):
+            return left * right
+        elif isinstance(operator, ast.Div):
+            return left / right
+        elif isinstance(operator, ast.FloorDiv):
+            return left // right
+        elif isinstance(operator, ast.Mod):
+            return left % right
+        elif isinstance(operator, ast.Pow):
+            return left**right
+        elif isinstance(operator, ast.LShift):
+            return left << right
+        elif isinstance(operator, ast.RShift):
+            return left >> right
+        elif isinstance(operator, ast.BitAnd):
+            return left & right
+        elif isinstance(operator, ast.BitOr):
+            return left | right
+        elif isinstance(operator, ast.BitXor):
+            return left ^ right
+        elif isinstance(operator, ast.MatMult):
+            return left @ right
+        else:
+            raise InterpreterError(f"Operator not supported: {operator}")
+
+    def _execute_unaryop(self, unaryop: ast.UnaryOp):
+        operand = self._execute_ast(unaryop.operand)
+        operator = unaryop.op
+
+        if isinstance(operator, ast.UAdd):
+            return +operand
+        elif isinstance(operator, ast.USub):
+            return -operand
+        elif isinstance(operator, ast.Not):
+            return not operand
+        elif isinstance(operator, ast.Invert):
+            return ~operand
+        else:
+            raise InterpreterError(f"Operator not supported: {operator}")
+
+    def _execute_listcomp(self, comp: ast.ListComp):
+        return [self._execute_comp(comp.elt, comp.generators)]
+
+    def _execute_dictcomp(self, comp: ast.DictComp):
+        return {
+            self._execute_comp(comp.key, comp.generators): self._execute_comp(
+                comp.value, comp.generators
+            )
+        }
+
+    def _execute_setcomp(self, comp: ast.SetComp):
+        return {self._execute_comp(comp.elt, comp.generators)}
+
+    def _execute_comp(self, elt, generators):
+        if not generators:
+            return self._execute_ast(elt)
+        gen = generators[0]
+        result = []
+        for value in self._execute_ast(gen.iter):
+            self._assign(gen.target, value)
+            if all(self._execute_condition(if_cond) for if_cond in gen.ifs):
+                result.extend(self._execute_comp(elt, generators[1:]))
+        return result
+
+    def _execute_generatorexp(self, genexp: ast.GeneratorExp):
+        def generator():
+            for value in self._execute_comp(genexp.elt, genexp.generators):
+                yield value
+
+        return generator()
+
+    def _get_value_from_state(self, key: str) -> Any:
+        if key in self.state:
+            return self.state[key]
+        elif key in self.fuzz_state:
+            return self.fuzz_state[key]
+        else:
+            raise InterpreterError(f"The variable `{key}` is not defined.")
+
+
+class TextPrompt(str):
+    r"""A class that represents a text prompt. The :obj:`TextPrompt` class
+    extends the built-in :obj:`str` class to provide a property for retrieving
+    the set of keywords in the prompt.
+    """
+
+    @property
+    def key_words(self) -> set[str]:
+        pattern = re.compile(r"\{([^{}]+)\}")
+        found = pattern.findall(self)
+        return set(found)
+
+    def format(self, *args: Any, **kwargs: Any) -> "TextPrompt":
+        default_kwargs = {key: "{" + f"{key}" + "}" for key in self.key_words}
+        default_kwargs.update(kwargs)
+        return TextPrompt(super().format(*args, **default_kwargs))
+
+
+class CodePrompt(TextPrompt):
+    r"""A class that represents a code prompt. It extends the :obj:`TextPrompt`
+    class with a :obj:`code_type` property.
+    """
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "CodePrompt":
+        code_type = kwargs.pop("code_type", None)
+        instance = super().__new__(cls, *args, **kwargs)
+        instance._code_type = code_type
+        return instance
+
+    @property
+    def code_type(self) -> str | None:
+        return self._code_type
+
+    def set_code_type(self, code_type: str) -> None:
+        self._code_type = code_type
+
+    def execute(
+        self,
+        interpreter: PythonInterpreter | None = None,
+        user_variable: dict[str, Any] | None = None,
+    ) -> tuple[Any, PythonInterpreter]:
+        if not interpreter:
+            interpreter = PythonInterpreter(action_space=globals())
+        execution_res = interpreter.execute(
+            self, fuzz_state=user_variable, keep_state=True
+        )
+        return execution_res, interpreter

{flock_core-0.2.5.dist-info → flock_core-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.2.5
+Version: 0.2.7
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -38,7 +38,9 @@ Description-Content-Type: text/markdown
 
 <p align="center">
 <img src="docs/img/flock.png" width="600"><br>
-<img alt="Dynamic TOML Badge" src="https://img.shields.io/badge/dynamic/toml?url=https%3A%2F%2Fraw.githubusercontent.com%2Fwhiteducksoftware%2Fflock%2Frefs%2Fheads%2Fbadges%2Fpyproject.toml%3Ftoken%3DGHSAT0AAAAAACVFDVNBU3S6HLJSC36P3YNQZ5LNPQQ&query=%24.project.version&style=for-the-badge&logo=pypi&logoSize=large&label=pip%20version&link=https%3A%2F%2Fpypi.org%2Fproject%2Fflock-core%2F">
+<img alt="Dynamic TOML Badge" src="https://img.shields.io/badge/dynamic/toml?url=https%3A%2F%2Fraw.githubusercontent.com%2Fwhiteducksoftware%2Fflock%2Frefs%2Fheads%2Fmaster%2Fpyproject.toml&query=%24.project.version&style=for-the-badge&logo=pypi&label=pip%20version">
+<img alt="X (formerly Twitter) Follow" src="https://img.shields.io/twitter/follow/whiteduck_gmbh?style=for-the-badge&logo=X">
+
 
 
 

{flock_core-0.2.5.dist-info → flock_core-0.2.7.dist-info}/RECORD

@@ -1,8 +1,8 @@
-flock/__init__.py,sha256=P175tsTOByIhw_CIeMAybUEggKhtoSrc8a0gKotBJfo,177
-flock/config.py,sha256=dyLqNng9ETTEx3CRCkz5N4g62Nu4ygPA6uQKEdbSgag,1499
+flock/__init__.py,sha256=JeRpPR29wyqXe8El-Ug4v_Ibhf5GQm_i8yWMi0cUYz0,36
+flock/config.py,sha256=jmW1PQ2oiCUpERLhNFzvrcHlYS3KM_jJyMXrnoeA0gs,1547
 flock/core/__init__.py,sha256=0Xq_txurlxxjKGXjRn6GNJusGTiBcd7zw2eF0L7JyuU,183
-flock/core/flock.py,sha256=0NC-J_ZCojwWDepI6rbX-9jG_Hr2AKgY43ieijhD8DU,9820
-flock/core/flock_agent.py,sha256=59qQ7ohOy2lc1KjI6SV7IcrqYL86ofAhq32pZGgk6eA,27761
+flock/core/flock.py,sha256=dyyLeCIUQ_tp-lUfbNphxwsIq8oWgEo8R2B6BhjeqTg,9826
+flock/core/flock_agent.py,sha256=prA2jslYuAABzIG6uw55f0XCNR-V4Ptaaju93ZuCc6E,27767
 flock/core/context/context.py,sha256=jH06w4C_O5CEL-YxjX_x_dmgLe9Rcllnn1Ebs0dvwaE,6171
 flock/core/context/context_manager.py,sha256=qMySVny_dbTNLh21RHK_YT0mNKIOrqJDZpi9ZVdBsxU,1103
 flock/core/context/context_vars.py,sha256=0Hn6fM2iNc0_jIIU0B7KX-K2o8qXqtZ5EYtwujETQ7U,272
@@ -14,7 +14,7 @@ flock/core/logging/telemetry.py,sha256=yEOfEZ3HBFeLCaHZA6QmsRdwZKtmUC6bQtEOTVeRR
 flock/core/logging/trace_and_logged.py,sha256=5vNrK1kxuPMoPJ0-QjQg-EDJL1oiEzvU6UNi6X8FiMs,2117
 flock/core/logging/formatters/base_formatter.py,sha256=CyG-X2NWq8sqEhFEO2aG7Mey5tVkIzoWiihW301_VIo,1023
 flock/core/logging/formatters/formatter_factory.py,sha256=hmH-NpCESHkioX0GBQ5CuQR4axyIXnSRWwAZCHylx6Q,1283
-flock/core/logging/formatters/pprint_formatter.py,sha256=tTm2WhwlCw-SX2Ouci5I9U_HVgxNGY5SSnzB9HZh8bg,692
+flock/core/logging/formatters/pprint_formatter.py,sha256=OubclvV_dSmbp0PKtdoz7UE-_x-DnBx7ykE4wowlha0,763
 flock/core/logging/formatters/rich_formatters.py,sha256=h1FD0_cIdQBQ8P2x05XhgD1cmmP80IBNVT5jb3cAV9M,4776
 flock/core/logging/formatters/theme_builder.py,sha256=1RUEwPIDfCjwTapbK1liasA5SdukOn7YwbZ4H4j1WkI,17364
 flock/core/logging/formatters/themed_formatter.py,sha256=CbxmqUC7zkLzyIxngk-3dcpQ6vxPR6zaDNA2TAMitCI,16714
@@ -22,14 +22,15 @@ flock/core/logging/span_middleware/baggage_span_processor.py,sha256=gJfRl8FeB6jd
 flock/core/logging/telemetry_exporter/base_exporter.py,sha256=rQJJzS6q9n2aojoSqwCnl7ZtHrh5LZZ-gkxUuI5WfrQ,1124
 flock/core/logging/telemetry_exporter/file_exporter.py,sha256=nKAjJSZtA7FqHSTuTiFtYYepaxOq7l1rDvs8U8rSBlA,3023
 flock/core/logging/telemetry_exporter/sqlite_exporter.py,sha256=CDsiMb9QcqeXelZ6ZqPSS56ovMPGqOu6whzBZRK__Vg,3498
-flock/core/mixin/dspy_integration.py,sha256=oT5YfXxPhHkMCuwhXoppBAYBGePUAKse7KebGSM-bq0,6880
+flock/core/mixin/dspy_integration.py,sha256=eFCe6B8vMmgKXY0eFIN_x_5DYyt0AZsffYXPSHTsO0U,7379
 flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgweoxI,5121
 flock/core/registry/agent_registry.py,sha256=QHdr3Cb-32PEdz8jFCIZSH9OlfpRwAJMtSRpHCWJDq4,4889
-flock/core/tools/basic_tools.py,sha256=nRc1bIz96z-WUTe_yYf9V6EfCPEncl_XnrpGdC7dEmo,8721
-flock/core/tools/dev_tools/github.py,sha256=6ya2_eN-qITV3b_pYP24jQC3X4oZbRY5GKh1AF-9Zic,6836
+flock/core/tools/basic_tools.py,sha256=OwWaFu4NoVrc3Uijj56RY9XDDaP_mOnEa5B3wSWwwLE,4756
+flock/core/tools/dev_tools/github.py,sha256=a2OTPXS7kWOVA4zrZHynQDcsmEi4Pac5MfSjQOLePzA,5308
 flock/core/util/cli_helper.py,sha256=aHLKjl5JBLIczLzjYeUcGQlVQRlypunxV2TYeAFX0KE,1030
-flock/core/util/input_resolver.py,sha256=OesGqX2Dld8myL9Qz04mmxLqoYqOSQC632pj1EMk9Yk,5456
+flock/core/util/input_resolver.py,sha256=g9vDPdY4OH-G7qjas5ksGEHueokHGFPMoLOvC-ngeLo,5984
 flock/core/util/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
+flock/interpreter/python_interpreter.py,sha256=pq2e7KJfAYtBCP2hhbtFNeg18QdMFF66esoYn3MHfA4,26177
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
 flock/platform/jaeger_install.py,sha256=MyOMJQx4TQSMYvdUJxfiGSo3YCtsfkbNXcAcQ9bjETA,2898
 flock/themes/3024-day.toml,sha256=uOVHqEzSyHx0WlUk3D0lne4RBsNBAPCTy3C58yU7kEY,667
@@ -373,8 +374,8 @@ flock/workflow/activities.py,sha256=YEg-Gr8kzVsxWsmsZguIVhX2XwMRvhZ2OlnsJoG5g_A,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.2.5.dist-info/METADATA,sha256=T9Yd-0aEUNgHlQnQp64zeDIkDgAsQRoPMF3WnBLUgCk,11564
-flock_core-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.2.5.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.2.5.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.2.5.dist-info/RECORD,,
+flock_core-0.2.7.dist-info/METADATA,sha256=eiHVseP4SIBpnZrObTM4r89jowE6p6h2lpCpNYFq4TA,11569
+flock_core-0.2.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.2.7.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.2.7.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.2.7.dist-info/RECORD,,