flock-core 0.5.0b28__py3-none-any.whl → 0.5.56b0__py3-none-any.whl

flock/core/util/splitter.py

@@ -1,219 +0,0 @@
-import re
-
-
-def split_top_level(spec: str) -> list[str]:
-    """Return raw field strings, split on *top-level* commas."""
-    fields: list[str] = []
-    start = 0
-    depth = 0
-    quote_char: str | None = None
-    i = 0
-    ident_re = re.compile(r"[A-Za-z_]\w*")  # cheap identifier
-
-    while i < len(spec):
-        ch = spec[i]
-
-        # ---------- string handling ----------
-        if quote_char:
-            if ch == "\\":
-                i += 2  # skip escaped char
-                continue
-            if ch == quote_char:
-                quote_char = None
-            i += 1
-            continue
-
-        if ch in {"'", '"'}:
-            prev = spec[i - 1] if i else " "
-            if (
-                depth or prev.isspace() or prev in "=([{,:"
-            ):  # looks like a quote
-                quote_char = ch
-            i += 1
-            continue
-
-        # ---------- bracket / brace / paren ----------
-        if ch in "([{":
-            depth += 1
-            i += 1
-            continue
-        if ch in ")]}":
-            depth = max(depth - 1, 0)
-            i += 1
-            continue
-
-        # ---------- field separators ----------
-        if ch == "," and depth == 0:
-            j = i + 1
-            while j < len(spec) and spec[j].isspace():
-                j += 1
-            if j >= len(spec):  # comma at end – split
-                fields.append(spec[start:i].strip())
-                start = i + 1
-                i += 1
-                continue
-
-            id_match = ident_re.match(spec, j)
-            if id_match:
-                k = id_match.end()
-                while k < len(spec) and spec[k].isspace():
-                    k += 1
-                if k >= len(spec) or spec[k] in {":", "|", ","}:
-                    # confirmed: comma separates two fields
-                    fields.append(spec[start:i].strip())
-                    start = i + 1
-                    i += 1
-                    continue
-
-        i += 1
-
-    fields.append(spec[start:].strip())
-    return [f for f in fields if f]  # prune empties
-
-
-def parse_schema(spec: str) -> list[tuple[str, str, str]]:
-    """Turn *spec* into a list of (name, python_type, description)."""
-    result: list[tuple[str, str, str]] = []
-
-    for field in split_top_level(spec):
-        name = ""
-        type_str = "str"  # default type
-        description = ""
-
-        name_part, _, desc_part = field.partition("|")
-        description = desc_part.strip()
-        main_part = name_part.strip()
-
-        if ":" in main_part:
-            name, type_candidate = main_part.split(":", 1)
-            name = name.strip()
-            type_candidate = type_candidate.strip()
-            if type_candidate:
-                type_str = type_candidate
-        else:
-            name = main_part  # keeps default type
-
-        if name:  # skip broken pieces
-            result.append((name, type_str, description))
-
-    return result
-
-
-# ------------------------------ demo ------------------------------
-if __name__ == "__main__":
-    SAMPLE_1 = (
-        " name: str | The character's full name,"
-        "race: str | The character's fantasy race,"
-        "class: Literal['mage','thief'] | The character's profession,"
-        "background: str | A brief backstory for the character"
-    )
-
-    SAMPLE_2 = (
-        "field_with_internal_quotes: Literal['type_A', "
-        '"type_B_with_\'_apostrophe"] | A literal with mixed quotes,'
-        " another_field :str| A field with a description"
-    )
-
-    SAMPLE_3 = (
-        "field_with_internal_quotes: Literal['type_A', "
-        '"type_B_with_\'_apostrophe"] | A literal with mixed quotes,'
-        " another_field | A field with a description"
-    )
-
-    SAMPLE_4 = "input, query, output"
-
-    SAMPLE_5 = (
-        "name: str | The character's full name,"
-        "race: str | The character's fantasy race,"
-        "class: Literal['mage','thief'] | The character's profession, which can be either mage or thief,"
-        "background: str | A brief backstory for the character"
-    )
-
-    SAMPLE_6 = (
-        "summary: str | A short blurb, e.g. key:value pairs that appear in logs"
-    )
-    # ➜ [('summary', 'str',
-    #     'A short blurb, e.g. key:value pairs that appear in logs')]
-
-    SAMPLE_7 = "path: str | The literal string 'C:\\\\Program Files\\\\My,App'"
-
-    # ➜ [('path', 'str',
-    #     "The literal string 'C:\\Program Files\\My,App'")]
-
-    SAMPLE_8 = (
-        "transform: Callable[[int, str], bool] | Function that returns True on success,"
-        "retries: int | How many times to retry"
-    )
-    # ➜ ('transform', 'Callable[[int, str], bool]', 'Function that returns True on success')
-    #    ('retries',   'int',                         'How many times to retry')
-
-    SAMPLE_9 = (
-        r"regex: str | Pattern such as r'^[A-Z\|a-z]+$',"
-        "flags: int | re flags to use"
-    )
-    # ➜ ('regex', 'str', "Pattern such as r'^[A-Z\\|a-z]+$'")
-    #    ('flags', 'int', 're flags to use')
-
-    SAMPLE_10 = "id:int, name:str,"  # note the final comma!
-    # ➜ ('id', 'int', '')
-    #    ('name', 'str', '')
-
-    SAMPLE_11 = "id:int | Primary key\nname:str | Display name\nactive:bool"
-    # ➜ should not work!
-
-    SAMPLE_12 = (
-        'comment:str | The text "done | failed" goes here,'
-        'status:Literal["done","failed"]'
-    )
-    # ➜ ('comment', 'str',    'The text "done | failed" goes here')
-    #    ('status',  'Literal["done","failed"]', '')
-
-    SAMPLE_13 = "choice: Literal['He said \\'yes\\'', 'no'] | User response"
-    # ➜ ('choice', "Literal['He said \\'yes\\'', 'no']", 'User response')
-
-    SAMPLE_14 = ""
-    # ➜ []
-
-    SAMPLE_15 = "username"
-    # ➜ [('username', 'str', '')]
-
-    SAMPLE_16 = (
-        "payload: dict[str, list[dict[str, tuple[int,str]]]] "
-        "| Arbitrarily complex structure"
-    )
-    # ➜ ('payload', 'dict[str, list[dict[str, tuple[int,str]]]]',
-    #     'Arbitrarily complex structure')
-
-    SAMPLE_17 = "münze: str | Deutsche Münzbezeichnung, engl. 'coin'"
-
-
-    SAMPLE_18 = "ticket_info : str, reasoning : str, search_queries : list[str], relevant_documents: dict[str, float] | dict of pdf_ids as keys and scores as values"
-
-
-    SAMPLE_19 = "title, headings: list[str], entities_and_metadata: list[dict[str, str]], type:Literal['news', 'blog', 'opinion piece', 'tweet']"
-    # ➜ [('münze', 'str', "Deutsche Münzbezeichnung, engl. 'coin'")]
-
-    for title, spec in [
-        ("Sample-1", SAMPLE_1),
-        ("Sample-2", SAMPLE_2),
-        ("Sample-3", SAMPLE_3),
-        ("Sample-4", SAMPLE_4),
-        ("Sample-5", SAMPLE_5),
-        ("Sample-6", SAMPLE_6),
-        ("Sample-7", SAMPLE_7),
-        ("Sample-8", SAMPLE_8),
-        ("Sample-9", SAMPLE_9),
-        ("Sample-10", SAMPLE_10),
-        ("Sample-11", SAMPLE_11),
-        ("Sample-12", SAMPLE_12),
-        ("Sample-13", SAMPLE_13),
-        ("Sample-14", SAMPLE_14),
-        ("Sample-15", SAMPLE_15),
-        ("Sample-16", SAMPLE_16),
-        ("Sample-17", SAMPLE_17),
-        ("Sample-18", SAMPLE_18),
-        ("Sample-19", SAMPLE_19),
-    ]:
-        print(f"\n{title}")
-        for row in parse_schema(spec):
-            print(row)

flock/di.py

@@ -1,27 +0,0 @@
-"""Flock - Dependency-Injection helpers.
-
-This module provides a small facade over `wd.di` so other parts of the
-codebase do not need to know where the active container is stored.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:  # pragma: no cover
-    from wd.di.container import (
-        ServiceProvider,  # noqa: F401 - import only for typing
-    )
-
-    from flock.core.context.context import FlockContext
-
-
-def get_current_container(context: FlockContext | None = None):
-    """Return the active `wd.di` container from *context* if present.
-
-    If *context* is ``None`` or no container has been attached to it the
-    function returns ``None``.
-    """
-    if context is None:
-        return None
-    return context.get_variable("di.container")

flock/platform/docker_tools.py

@@ -1,49 +0,0 @@
-import asyncio
-import subprocess
-
-
-def _check_docker_running():
-    """Check if Docker is running by calling 'docker info'."""
-    try:
-        result = subprocess.run(
-            ["docker", "info"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        return result.returncode == 0
-    except Exception:
-        return False
-
-
-async def _start_docker():
-    """Attempt to start Docker.
-    This example first tries 'systemctl start docker' and then 'service docker start'.
-    Adjust as needed for your environment.
-    """
-    try:
-        print("Attempting to start Docker...")
-        result = subprocess.run(
-            ["sudo", "systemctl", "start", "docker"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        if result.returncode != 0:
-            result = subprocess.run(
-                ["sudo", "service", "docker", "start"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-        # Give Docker a moment to start.
-        await asyncio.sleep(3)
-        if _check_docker_running():
-            print("Docker is now running.")
-            return True
-        else:
-            print("Docker did not start successfully.")
-            return False
-    except Exception as e:
-        print(f"Exception when trying to start Docker: {e}")
-        return False

flock/platform/jaeger_install.py

@@ -1,86 +0,0 @@
-import socket
-import subprocess
-from urllib.parse import urlparse
-
-
-class JaegerInstaller:
-    jaeger_endpoint: str = None
-    jaeger_transport: str = "grpc"
-
-    def _check_jaeger_running(self):
-        """Check if Jaeger is reachable by attempting a socket connection.
-        For HTTP transport, we parse the URL; for gRPC, we expect "host:port".
-        """
-        try:
-            if self.jaeger_transport == "grpc":
-                host, port = self.jaeger_endpoint.split(":")
-                port = int(port)
-            elif self.jaeger_transport == "http":
-                parsed = urlparse(self.jaeger_endpoint)
-                host = parsed.hostname
-                port = parsed.port if parsed.port else 80
-            else:
-                return False
-
-            # Try connecting to the host and port.
-            with socket.create_connection((host, port), timeout=3):
-                return True
-        except Exception:
-            return False
-
-    def _is_jaeger_container_running(self):
-        """Check if a Jaeger container (using the official all-in-one image) is running.
-        This uses 'docker ps' to filter for containers running the Jaeger image.
-        """
-        try:
-            result = subprocess.run(
-                [
-                    "docker",
-                    "ps",
-                    "--filter",
-                    "ancestor=jaegertracing/all-in-one:latest",
-                    "--format",
-                    "{{.ID}}",
-                ],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            return bool(result.stdout.strip())
-        except Exception:
-            return False
-
-    def _provision_jaeger_container(self):
-        """Provision a Jaeger container using Docker."""
-        try:
-            print("Provisioning Jaeger container using Docker...")
-            result = subprocess.run(
-                [
-                    "docker",
-                    "run",
-                    "-d",
-                    "--name",
-                    "jaeger",
-                    "-p",
-                    "16686:16686",
-                    "-p",
-                    "14250:14250",
-                    "-p",
-                    "14268:14268",
-                    "jaegertracing/all-in-one:latest",
-                ],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            if result.returncode == 0:
-                print("Jaeger container started successfully.")
-                return True
-            else:
-                print(
-                    f"Failed to start Jaeger container. Error: {result.stderr}"
-                )
-                return False
-        except Exception as e:
-            print(f"Exception when provisioning Jaeger container: {e}")
-            return False

flock/webapp/__init__.py

@@ -1 +0,0 @@
-"""Flock Web Application Package."""

flock/webapp/app/api/agent_management.py

@@ -1,241 +0,0 @@
-# src/flock/webapp/app/api/agent_management.py
-import json
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-from fastapi import (  # Added Depends and HTTPException
-    APIRouter,
-    Depends,
-    Form,
-    Request,
-)
-from fastapi.responses import HTMLResponse
-from fastapi.templating import Jinja2Templates
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-
-# Import the dependency to get the current Flock instance
-from flock.webapp.app.dependencies import (
-    get_flock_instance,
-    get_optional_flock_instance,
-)
-
-# Import service functions that now take app_state (or directly the Flock instance)
-from flock.webapp.app.services.flock_service import (
-    add_agent_to_current_flock_service,
-    get_registered_items_service,  # This is fine as it doesn't depend on current_flock
-    remove_agent_from_current_flock_service,
-    update_agent_in_current_flock_service,
-)
-
-router = APIRouter()
-BASE_DIR = Path(__file__).resolve().parent.parent.parent # Points to flock-ui/
-templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
-
-
-@router.get("/htmx/agent-list", response_class=HTMLResponse)
-async def htmx_get_agent_list(
-    request: Request,
-    message: str = None,
-    success: bool = None,
-    # Use Depends to get the current flock instance.
-    # Use get_optional_flock_instance if the route should work even without a flock loaded.
-    current_flock: "Flock | None" = Depends(get_optional_flock_instance)
-):
-    if not current_flock:
-        # If used in a context where flock might not be loaded (e.g. main agent manager view before load)
-        # it should be handled by the page template or a higher-level redirect.
-        # For a partial, returning an error or empty state is reasonable.
-        return HTMLResponse("<div id='agent-list-container'><p class='error'>No Flock loaded to display agents.</p></div>", headers={"HX-Retarget": "#agent-list-container", "HX-Reswap": "innerHTML"})
-
-    return templates.TemplateResponse(
-        "partials/_agent_list.html",
-        {
-            "request": request,
-            "flock": current_flock, # Pass the injected flock instance
-            "message": message,
-            "success": success,
-        },
-    )
-
-
-@router.get("/htmx/agents/{agent_name}/details-form", response_class=HTMLResponse)
-async def htmx_get_agent_details_form(
-    request: Request,
-    agent_name: str,
-    current_flock: "Flock" = Depends(get_flock_instance) # Expect flock to be loaded
-):
-    # flock instance is now injected by FastAPI
-    agent = current_flock.agents.get(agent_name)
-    if not agent:
-        return HTMLResponse(
-            f"<p class='error'>Agent '{agent_name}' not found in the current Flock.</p>"
-        )
-
-    registered_tools = get_registered_items_service("tool")
-    current_agent_tools = (
-        [tool.__name__ for tool in agent.tools] if agent.tools else []
-    )
-
-    return templates.TemplateResponse(
-        "partials/_agent_detail_form.html",
-        {
-            "request": request,
-            "agent": agent,
-            "is_new": False,
-            "registered_tools": registered_tools,
-            "current_tools": current_agent_tools,
-        },
-    )
-
-
-@router.get("/htmx/agents/new-agent-form", response_class=HTMLResponse)
-async def htmx_get_new_agent_form(
-    request: Request,
-    current_flock: "Flock" = Depends(get_flock_instance) # Expect flock for context, even for new agent
-):
-    # current_flock is injected, primarily to ensure context if needed by template/tools list
-    registered_tools = get_registered_items_service("tool")
-    return templates.TemplateResponse(
-        "partials/_agent_detail_form.html",
-        {
-            "request": request,
-            "agent": None,
-            "is_new": True,
-            "registered_tools": registered_tools,
-            "current_tools": [],
-        },
-    )
-
-
-@router.post("/htmx/agents", response_class=HTMLResponse)
-async def htmx_create_agent(
-    request: Request,
-    agent_name: str = Form(...),
-    agent_description: str = Form(""),
-    agent_model: str = Form(None),
-    input_signature: str = Form(...),
-    output_signature: str = Form(...),
-    tools: list[str] = Form([]),
-    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
-):
-    # The service function add_agent_to_current_flock_service now takes app_state
-    if (not agent_name.strip() or not input_signature.strip() or not output_signature.strip()):
-        registered_tools = get_registered_items_service("tool")
-        return templates.TemplateResponse(
-            "partials/_agent_detail_form.html",
-            {
-                "request": request, "agent": None, "is_new": True,
-                "error_message": "Name, Input Signature, and Output Signature are required.",
-                "registered_tools": registered_tools, "current_tools": tools,
-            })
-
-    agent_config = {
-        "name": agent_name, "description": agent_description,
-        "model": agent_model if agent_model and agent_model.strip() else None,
-        "input": input_signature, "output": output_signature, "tools_names": tools,
-    }
-    # Pass request.app.state to the service function
-    success = add_agent_to_current_flock_service(agent_config, request.app.state)
-
-    response_headers = {}
-    if success:
-        response_headers["HX-Trigger"] = json.dumps({"agentListChanged": None, "notify": {"type":"success", "message": f"Agent '{agent_name}' created."}})
-
-
-    # Re-render the form or an empty state for the detail panel
-    # The agent list itself will be refreshed by the agentListChanged trigger
-    new_form_context = {
-        "request": request, "agent": None, "is_new": True,
-        "registered_tools": get_registered_items_service("tool"),
-        "current_tools": [], # Reset tools for new form
-        "form_message": "Agent created successfully!" if success else "Failed to create agent. Check logs.",
-        "success": success,
-    }
-    return templates.TemplateResponse("partials/_agent_detail_form.html", new_form_context, headers=response_headers)
-
-
-@router.put("/htmx/agents/{original_agent_name}", response_class=HTMLResponse)
-async def htmx_update_agent(
-    request: Request,
-    original_agent_name: str,
-    agent_name: str = Form(...),
-    agent_description: str = Form(""),
-    agent_model: str = Form(None),
-    input_signature: str = Form(...),
-    output_signature: str = Form(...),
-    tools: list[str] = Form([]),
-    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
-):
-    agent_config = {
-        "name": agent_name, "description": agent_description,
-        "model": agent_model if agent_model and agent_model.strip() else None,
-        "input": input_signature, "output": output_signature, "tools_names": tools,
-    }
-    # Pass request.app.state
-    success = update_agent_in_current_flock_service(original_agent_name, agent_config, request.app.state)
-
-    response_headers = {}
-    if success:
-        response_headers["HX-Trigger"] = json.dumps({"agentListChanged": None, "notify": {"type":"success", "message": f"Agent '{agent_name}' updated."}})
-
-
-    # After update, get the (potentially renamed) agent from app.state's flock
-    updated_agent_instance: Flock | None = getattr(request.app.state, 'flock_instance', None)
-    updated_agent = updated_agent_instance.agents.get(agent_name) if updated_agent_instance else None
-
-    registered_tools = get_registered_items_service("tool")
-    current_agent_tools = []
-    if updated_agent and updated_agent.tools:
-        current_agent_tools = [tool.__name__ for tool in updated_agent.tools]
-
-    updated_form_context = {
-        "request": request, "agent": updated_agent, "is_new": False,
-        "form_message": "Agent updated successfully!" if success else "Failed to update agent. Check logs.",
-        "success": success,
-        "registered_tools": registered_tools, "current_tools": current_agent_tools,
-    }
-    return templates.TemplateResponse("partials/_agent_detail_form.html", updated_form_context, headers=response_headers)
-
-
-@router.delete("/htmx/agents/{agent_name}", response_class=HTMLResponse)
-async def htmx_delete_agent(
-    request: Request,
-    agent_name: str,
-    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
-):
-    # Pass request.app.state
-    success = remove_agent_from_current_flock_service(agent_name, request.app.state)
-    response_headers = {}
-
-    if success:
-        response_headers["HX-Trigger"] = json.dumps({"agentListChanged": None, "notify": {"type":"info", "message": f"Agent '{agent_name}' removed."}})
-        # Return an empty agent detail form to clear that panel
-        empty_form_context = {
-            "request": request, "agent": None, "is_new": True,
-            "registered_tools": get_registered_items_service("tool"),
-            "current_tools": [],
-            # "form_message": f"Agent '{agent_name}' removed.", # Message handled by notify
-            # "success": True, # Not strictly needed if form is cleared
-        }
-        return templates.TemplateResponse("partials/_agent_detail_form.html", empty_form_context, headers=response_headers)
-    else:
-        # Deletion failed, re-render the form for the agent that failed to delete (if it still exists)
-        flock_instance_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
-        agent_still_exists = flock_instance_from_state.agents.get(agent_name) if flock_instance_from_state else None
-
-        registered_tools = get_registered_items_service("tool")
-        current_tools = []
-        if agent_still_exists and agent_still_exists.tools:
-            current_tools = [tool.__name__ for tool in agent_still_exists.tools]
-
-        error_form_context = {
-            "request": request, "agent": agent_still_exists, "is_new": False,
-            "form_message": f"Failed to remove agent '{agent_name}'. It might have already been removed or an error occurred.",
-            "success": False,
-            "registered_tools": registered_tools, "current_tools": current_tools,
-        }
-        # Trigger a notification for the error as well
-        response_headers["HX-Trigger"] = json.dumps({"notify": {"type":"error", "message": f"Failed to remove agent '{agent_name}'."}})
-        return templates.TemplateResponse("partials/_agent_detail_form.html", error_form_context, headers=response_headers)