flock-core 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

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.