flock-core 0.5.0b5__py3-none-any.whl → 0.5.0b6__py3-none-any.whl

flock/tools/code_tools.py

@@ -1,167 +0,0 @@
-from flock.core.interpreter.python_interpreter import PythonInterpreter
-from flock.core.logging.trace_and_logged import traced_and_logged
-
-
-@traced_and_logged
-def code_evaluate_math(expression: str) -> float:
-    try:
-        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_code_eval(python_code: str) -> str:
-    """A Python code evaluation tool that executes Python code and returns the result.
-    
-    The code may not be markdown-escaped with triple backticks.
-    It is expected to be a valid Python code snippet that can be executed directly.
-    The code is executed in a controlled environment with a limited set of libraries.
-    It allows the use of the following libraries:
-                "os",
-                "math",
-                "random",
-                "datetime",
-                "time",
-                "string",
-                "collections",
-                "itertools",
-                "functools",
-                "typing",
-                "enum",
-                "json",
-                "ast",
-                "numpy",
-                "sympy",
-                "pandas",
-                "httpx",
-    """
-    try:
-        result = PythonInterpreter(
-            {},
-            [
-                "os",
-                "math",
-                "random",
-                "datetime",
-                "time",
-                "string",
-                "collections",
-                "itertools",
-                "functools",
-                "typing",
-                "enum",
-                "json",
-                "ast",
-                "numpy",
-                "sympy",
-                "pandas",
-            ],
-            verbose=True,
-        ).execute(python_code)
-        return result
-    except Exception:
-        raise
-
-
-@traced_and_logged
-def docker_code_execute(python_code: str) -> str:
-    """Execute Python code in a sandboxed Docker container."""
-    import ast
-    import os
-    import pathlib
-    import platform
-    import shutil
-    import textwrap
-    import uuid
-
-    import docker
-    def _auto_print_last_expr(code: str) -> str:
-        """If the last top-level statement is a bare expression,
-        append a print() so script mode surfaces its value.
-        """
-        tree = ast.parse(code, mode="exec")
-        if tree.body and isinstance(tree.body[-1], ast.Expr):
-            # Re-extract the exact source of that expression
-            expr_src = textwrap.dedent(
-                code.splitlines()[tree.body[-1].lineno - 1]
-            )
-            code += f"\nprint({expr_src})"
-        return code
-    # --- 1. Figure out a base directory that exists on this OS ----------
-    if platform.system() == "Windows":
-        base_dir = pathlib.Path(os.getenv("SANDBOX_BASE_DIR", r"C:\sandboxes"))
-    else:  # Linux, macOS, WSL2
-        base_dir = pathlib.Path(os.getenv("SANDBOX_BASE_DIR", "/var/sandboxes"))
-
-    base_dir.mkdir(parents=True, exist_ok=True)
-
-    sandbox_id = f"sbox-{uuid.uuid4()}"
-    workdir = base_dir / sandbox_id
-    workdir.mkdir(parents=True, exist_ok=False)
-
-    # Docker’s HTTP API always wants POSIX‐style paths (“/”, drive letter allowed).
-    host_path = workdir.resolve().as_posix()        # e.g. "C:/sandboxes/…"
-
-    client = docker.from_env()
-    image = "python:3.12-slim"
-
-    # --- 2. Decide whether we can / should request the gVisor runtime ---
-    runtime_args = {}
-    if platform.system() != "Windows" and shutil.which("runsc"):
-        runtime_args["runtime"] = "runsc"           # gVisor on Linux & macOS
-
-    container = client.containers.run(
-        image,
-        name=sandbox_id,
-        command=["sleep", "infinity"],
-        user="65534:65534",                # nobody
-        network_mode="none",
-        volumes={host_path: {"bind": "/workspace", "mode": "rw"}},
-        mem_limit="4g",
-        cpu_period=100_000,
-        cpu_quota=200_000,                 # 2 vCPU
-        security_opt=["no-new-privileges"],
-        detach=True,
-        **runtime_args,
-    )
-
-    try:
-        def exec_code(cmd: list[str], timeout: int = 30) -> str:
-            exec_id = client.api.exec_create(
-                container.id, cmd, workdir="/workspace"
-            )["Id"]
-            return client.api.exec_start(
-                exec_id, stream=False, demux=False, tty=False,
-            ).decode()
-
-        # --- 3. Copy code in and execute --------------------------------
-        (workdir / "main.py").write_text(_auto_print_last_expr(python_code), encoding="utf-8")
-        stdout = exec_code(["python", "main.py"], timeout=30)
-        return stdout.strip()
-
-    finally:
-        # --- 4. Tear everything down ------------------------------------
-        container.remove(force=True)
-        shutil.rmtree(workdir, ignore_errors=True)
-
-

flock/tools/file_tools.py

@@ -1,149 +0,0 @@
-import importlib
-import json
-from typing import Any
-
-from flock.core.logging.trace_and_logged import traced_and_logged
-
-
-@traced_and_logged
-def file_get_anything_as_markdown(url_or_file_path: str):
-    if importlib.util.find_spec("docling") is not None:
-        from docling.document_converter import DocumentConverter
-
-        try:
-            converter = DocumentConverter()
-            result = converter.convert(url_or_file_path)
-            markdown = result.document.export_to_markdown()
-            return markdown
-        except Exception:
-            raise
-    else:
-        raise ImportError(
-            "Optional tool dependencies not installed. Install with 'pip install flock-core[file-tools]'."
-        )
-
-
-@traced_and_logged
-def file_append_to_file(content: str, filename: str):
-    try:
-        with open(filename, "a", encoding="utf-8") as f:
-            f.write(content)
-    except Exception:
-        raise
-
-
-@traced_and_logged
-def file_save_to_file(content: str, filename: str):
-    try:
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write(content)
-    except Exception:
-        raise
-
-
-@traced_and_logged
-def file_read_from_file(filename: str) -> str:
-    with open(filename, encoding="utf-8") as file:
-        return file.read()
-
-
-@traced_and_logged
-def file_json_parse_safe(text: str) -> dict:
-    try:
-        result = json.loads(text)
-        return result
-    except Exception:
-        return {}
-
-
-@traced_and_logged
-def file_json_search(
-    json_file_path: str, search_query: str, case_sensitive: bool = False
-) -> list:
-    """Search a JSON file for objects containing the specified search query.
-
-    Args:
-        json_file_path (str): Path to the JSON file to search
-        search_query (str): Text to search for within the JSON objects
-        case_sensitive (bool, optional): Whether to perform a case-sensitive search. Defaults to False.
-
-    Returns:
-        list: List of JSON objects (as dicts) that contain the search query
-
-    Example:
-        >>> matching_tickets = file_json_search("tickets.json", "error 404")
-        >>> print(
-        ...     f"Found {len(matching_tickets)} tickets mentioning '404 error'"
-        ... )
-    """
-    try:
-        # Read the JSON file
-        file_content = file_read_from_file(json_file_path)
-
-        # Parse the JSON content
-        json_data = file_json_parse_safe(file_content)
-
-        # Convert search query to lowercase if case-insensitive search
-        if not case_sensitive:
-            search_query = search_query.lower()
-
-        results = []
-
-        # Determine if the JSON root is an object or array
-        if isinstance(json_data, dict):
-            # Handle case where root is a dictionary object
-            for key, value in json_data.items():
-                if isinstance(value, list):
-                    # If this key contains a list of objects, search within them
-                    matching_items = _search_in_list(
-                        value, search_query, case_sensitive
-                    )
-                    results.extend(matching_items)
-                elif _contains_text(value, search_query, case_sensitive):
-                    # The entire object matches
-                    results.append(json_data)
-                    break
-        elif isinstance(json_data, list):
-            # Handle case where root is an array
-            matching_items = _search_in_list(
-                json_data, search_query, case_sensitive
-            )
-            results.extend(matching_items)
-
-        return results
-
-    except Exception as e:
-        return [{"error": f"Error searching JSON file: {e!s}"}]
-
-
-def _search_in_list(
-    items: list, search_query: str, case_sensitive: bool
-) -> list:
-    """Helper function to search for text in a list of items."""
-    matching_items = []
-    for item in items:
-        if _contains_text(item, search_query, case_sensitive):
-            matching_items.append(item)
-    return matching_items
-
-
-def _contains_text(obj: Any, search_query: str, case_sensitive: bool) -> bool:
-    """Recursively check if an object contains the search query in any of its string values."""
-    if isinstance(obj, str):
-        # For string values, check if they contain the search query
-        if case_sensitive:
-            return search_query in obj
-        else:
-            return search_query in obj.lower()
-    elif isinstance(obj, dict):
-        # For dictionaries, check each value
-        for value in obj.values():
-            if _contains_text(value, search_query, case_sensitive):
-                return True
-    elif isinstance(obj, list):
-        # For lists, check each item
-        for item in obj:
-            if _contains_text(item, search_query, case_sensitive):
-                return True
-    # For other types (numbers, booleans, None), return False
-    return False

flock/tools/github_tools.py

@@ -1,157 +0,0 @@
-"""This module provides tools for interacting with GitHub repositories."""
-
-import base64
-import os
-
-import httpx
-
-from flock.core.logging.trace_and_logged import traced_and_logged
-
-
-@traced_and_logged
-def github_create_user_stories_as_github_issue(title: str, body: str) -> str:
-    github_pat = os.getenv("GITHUB_PAT")
-    github_repo = os.getenv("GITHUB_REPO")
-
-    url = f"https://api.github.com/repos/{github_repo}/issues"
-    headers = {
-        "Authorization": f"Bearer {github_pat}",
-        "Accept": "application/vnd.github+json",
-    }
-    issue_title = title
-    issue_body = body
-
-    payload = {"title": issue_title, "body": issue_body}
-    response = httpx.post(url, json=payload, headers=headers)
-
-    if response.status_code == 201:
-        return "Issue created successfully."
-    else:
-        return "Failed to create issue. Please try again later."
-
-
-@traced_and_logged
-def github_upload_readme(content: str):
-    GITHUB_USERNAME = os.getenv("GITHUB_USERNAME")
-    REPO_NAME = os.getenv("GITHUB_REPO")
-    GITHUB_TOKEN = os.getenv("GITHUB_PAT")
-
-    if not GITHUB_USERNAME or not REPO_NAME or not GITHUB_TOKEN:
-        raise ValueError(
-            "Missing environment variables: GITHUB_USERNAME, GITHUB_REPO, or GITHUB_PAT"
-        )
-
-    GITHUB_API_URL = f"https://api.github.com/repos/{GITHUB_USERNAME}/{REPO_NAME}/contents/README.md"
-
-    encoded_content = base64.b64encode(content.encode()).decode()
-
-    with httpx.Client() as client:
-        response = client.get(
-            GITHUB_API_URL,
-            headers={
-                "Authorization": f"Bearer {GITHUB_TOKEN}",
-                "Accept": "application/vnd.github.v3+json",
-            },
-        )
-
-        data = response.json()
-        sha = data.get("sha", None)
-
-        payload = {
-            "message": "Updating README.md",
-            "content": encoded_content,
-            "branch": "main",
-        }
-
-        if sha:
-            payload["sha"] = sha
-
-        response = client.put(
-            GITHUB_API_URL,
-            json=payload,
-            headers={
-                "Authorization": f"Bearer {GITHUB_TOKEN}",
-                "Accept": "application/vnd.github.v3+json",
-            },
-        )
-
-        if response.status_code in [200, 201]:
-            print("README.md successfully uploaded/updated!")
-        else:
-            print("Failed to upload README.md:", response.json())
-
-
-@traced_and_logged
-def github_create_files(file_paths) -> str:
-    """Create multiple files in a GitHub repository with a predefined content.
-
-    This function iterates over a list of file paths (relative to the repository root) and creates
-    each file in the specified GitHub repository with the content "#created by flock". For each file,
-    it checks whether the file already exists; if it does, that file is skipped. The function
-    uses the following environment variables for authentication and repository information:
-
-      - GITHUB_USERNAME: Your GitHub username.
-      - GITHUB_REPO: The name of the repository.
-      - GITHUB_PAT: Your GitHub Personal Access Token for authentication.
-
-    Parameters:
-        file_paths (list of str): A list of file paths (relative to the repository root) to be created.
-
-    Returns:
-        str: A message indicating whether the files were created successfully or if there was a failure.
-    """
-    try:
-        GITHUB_USERNAME = os.getenv("GITHUB_USERNAME")
-        REPO_NAME = os.getenv("GITHUB_REPO")
-        GITHUB_TOKEN = os.getenv("GITHUB_PAT")
-
-        if not GITHUB_USERNAME or not REPO_NAME or not GITHUB_TOKEN:
-            raise ValueError(
-                "Missing environment variables: GITHUB_USERNAME, GITHUB_REPO, or GITHUB_PAT"
-            )
-
-        encoded_content = base64.b64encode(b"#created by flock").decode()
-
-        with httpx.Client() as client:
-            for file_path in file_paths:
-                GITHUB_API_URL = f"https://api.github.com/repos/{GITHUB_USERNAME}/{REPO_NAME}/contents/{file_path}"
-
-                response = client.get(
-                    GITHUB_API_URL,
-                    headers={
-                        "Authorization": f"token {GITHUB_TOKEN}",
-                        "Accept": "application/vnd.github.v3+json",
-                    },
-                )
-
-                data = response.json()
-                sha = data.get("sha", None)
-
-                payload = {
-                    "message": f"Creating {file_path}",
-                    "content": encoded_content,
-                    "branch": "main",
-                }
-
-                if sha:
-                    print(f"Skipping {file_path}, file already exists.")
-                    continue
-
-                response = client.put(
-                    GITHUB_API_URL,
-                    json=payload,
-                    headers={
-                        "Authorization": f"token {GITHUB_TOKEN}",
-                        "Accept": "application/vnd.github.v3+json",
-                    },
-                )
-
-                if response.status_code in [200, 201]:
-                    print(f"{file_path} successfully created!")
-                else:
-                    print(f"Failed to create {file_path}:", response.json())
-
-        return "Files created successfully."
-
-    except Exception:
-        return "Failed to create file. Please try again later."

flock/tools/markdown_tools.py

@@ -1,204 +0,0 @@
-import re
-from typing import Any
-
-from flock.core.logging.trace_and_logged import traced_and_logged
-
-
-@traced_and_logged
-def markdown_split_by_headers(
-    markdown_text: str, min_header_level: int = 1, max_header_level: int = 2
-) -> list[dict[str, Any]]:
-    if not markdown_text:
-        return []
-
-    # Pattern to match headers from level min_header_level to max_header_level
-    header_pattern = re.compile(
-        f"^({'#' * min_header_level}){{'1,{max_header_level - min_header_level + 1}'}}\\s+(.+)$",
-        re.MULTILINE,
-    )
-
-    # Find all headers
-    headers = list(header_pattern.finditer(markdown_text))
-
-    if not headers:
-        return [{"title": "Text", "content": markdown_text, "level": 0}]
-
-    chunks = []
-
-    # Process each section
-    for i, current_header in enumerate(headers):
-        header_text = current_header.group(2).strip()
-        header_level = len(current_header.group(1))
-
-        # Determine section content
-        if i < len(headers) - 1:
-            next_header_start = headers[i + 1].start()
-            content = markdown_text[current_header.end() : next_header_start]
-        else:
-            content = markdown_text[current_header.end() :]
-
-        chunks.append(
-            {
-                "title": header_text,
-                "content": content.strip(),
-                "level": header_level,
-            }
-        )
-
-    # Check if there's content before the first header
-    if headers[0].start() > 0:
-        preamble = markdown_text[: headers[0].start()].strip()
-        if preamble:
-            chunks.insert(
-                0, {"title": "Preamble", "content": preamble, "level": 0}
-            )
-
-    return chunks
-
-
-@traced_and_logged
-def markdown_extract_code_blocks(
-    markdown_text: str, language: str = None
-) -> list[dict[str, str]]:
-    if not markdown_text:
-        return []
-
-    # Pattern to match markdown code blocks
-    if language:
-        # Match only code blocks with the specified language
-        pattern = rf"```{language}\s*([\s\S]*?)\s*```"
-    else:
-        # Match all code blocks, capturing the language specifier if present
-        pattern = r"```(\w*)\s*([\s\S]*?)\s*```"
-
-    blocks = []
-
-    if language:
-        # If language is specified, we only capture the code content
-        matches = re.finditer(pattern, markdown_text)
-        for match in matches:
-            blocks.append(
-                {"language": language, "code": match.group(1).strip()}
-            )
-    else:
-        # If no language is specified, we capture both language and code content
-        matches = re.finditer(pattern, markdown_text)
-        for match in matches:
-            lang = match.group(1).strip() if match.group(1) else "text"
-            blocks.append({"language": lang, "code": match.group(2).strip()})
-
-    return blocks
-
-
-@traced_and_logged
-def markdown_extract_links(markdown_text: str) -> list[dict[str, str]]:
-    if not markdown_text:
-        return []
-
-    # Pattern to match markdown links [text](url)
-    link_pattern = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
-    matches = link_pattern.findall(markdown_text)
-
-    return [{"text": text, "url": url} for text, url in matches]
-
-
-@traced_and_logged
-def markdown_extract_tables(markdown_text: str) -> list[dict[str, Any]]:
-    if not markdown_text:
-        return []
-
-    # Split the text by lines
-    lines = markdown_text.split("\n")
-
-    tables = []
-    current_table = None
-    header_row = None
-
-    for line in lines:
-        line = line.strip()
-
-        # Table rows are indicated by starting with |
-        if line.startswith("|") and line.endswith("|"):
-            if current_table is None:
-                current_table = []
-                # This is the header row
-                header_row = [
-                    cell.strip() for cell in line.strip("|").split("|")
-                ]
-            elif "|--" in line or "|:-" in line:
-                # This is the separator row, ignore it
-                pass
-            else:
-                # This is a data row
-                row_data = [cell.strip() for cell in line.strip("|").split("|")]
-
-                # Create a dictionary mapping headers to values
-                row_dict = {}
-                for i, header in enumerate(header_row):
-                    if i < len(row_data):
-                        row_dict[header] = row_data[i]
-                    else:
-                        row_dict[header] = ""
-
-                current_table.append(row_dict)
-        else:
-            # End of table
-            if current_table is not None:
-                tables.append({"headers": header_row, "rows": current_table})
-                current_table = None
-                header_row = None
-
-    # Don't forget to add the last table if we're at the end of the document
-    if current_table is not None:
-        tables.append({"headers": header_row, "rows": current_table})
-
-    return tables
-
-
-@traced_and_logged
-def markdown_to_plain_text(markdown_text: str) -> str:
-    if not markdown_text:
-        return ""
-
-    # Replace headers
-    text = re.sub(r"^#{1,6}\s+(.+)$", r"\1", markdown_text, flags=re.MULTILINE)
-
-    # Replace bold and italic
-    text = re.sub(r"\*\*(.*?)\*\*", r"\1", text)
-    text = re.sub(r"__(.*?)__", r"\1", text)
-    text = re.sub(r"\*(.*?)\*", r"\1", text)
-    text = re.sub(r"_(.*?)_", r"\1", text)
-
-    # Replace links
-    text = re.sub(r"\[(.*?)\]\((.*?)\)", r"\1 (\2)", text)
-
-    # Replace code blocks
-    text = re.sub(r"```(?:\w+)?\s*([\s\S]*?)\s*```", r"\1", text)
-    text = re.sub(r"`([^`]*?)`", r"\1", text)
-
-    # Replace bullet points
-    text = re.sub(r"^[\*\-\+]\s+(.+)$", r"• \1", text, flags=re.MULTILINE)
-
-    # Replace numbered lists (keeping the numbers)
-    text = re.sub(r"^\d+\.\s+(.+)$", r"\1", text, flags=re.MULTILINE)
-
-    # Replace blockquotes
-    text = re.sub(r"^>\s+(.+)$", r"\1", text, flags=re.MULTILINE)
-
-    # Remove HTML tags
-    text = re.sub(r"<.*?>", "", text)
-
-    # Normalize whitespace
-    text = re.sub(r"\n{3,}", "\n\n", text)
-
-    return text.strip()
-
-
-
-@traced_and_logged
-def extract_links_from_markdown(markdown: str, url: str) -> list:
-    # Regular expression to find all markdown links
-    link_pattern = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
-    links = link_pattern.findall(markdown)
-    return [url + link[1] for link in links]
-

flock/tools/system_tools.py

@@ -1,9 +0,0 @@
-from flock.core.logging.trace_and_logged import traced_and_logged
-
-
-@traced_and_logged
-def get_current_time() -> str:
-    import datetime
-
-    time = datetime.datetime.now().isoformat()
-    return time