flock-core 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

flock/app/modules/settings.py

@@ -1,96 +0,0 @@
-"""FrankenUI Forms Example built with MonsterUI (original design by ShadCN)"""
-
-from fasthtml.common import *
-from fasthtml.svg import *
-from monsterui.all import *
-
-from flock.app.components import ThemeDialog
-
-
-def HelpText(c):
-    return P(c, cls=TextFont.muted_sm)
-
-
-def heading():
-    return Div(cls="px-4 py-2 ")(
-        H3("Settings"),
-        P("Manage your account settings and set e-mail preferences.", cls=TextFont.muted_lg),
-        DividerSplit(),
-    )
-
-
-sidebar_items = ["API Keys", "Appearance", "Display"]
-
-sidebar = NavContainer(
-    *map(lambda x: Li(A(x)), sidebar_items),
-    uk_switcher="connect: #component-nav; animation: uk-animation-fade",
-    cls=(NavT.secondary, "space-y-4 p-4 w-1/5"),
-)
-
-
-def FormSectionDiv(*c, cls="space-y-2", **kwargs):
-    return Div(*c, cls=cls, **kwargs)
-
-
-def api_key_form():
-    content = (
-        FormSectionDiv(
-            LabelInput("Open AI API Key", placeholder="sk-...", id="username"),
-            HelpText("This is your Open AI API key. You can find it in your account settings. "),
-        ),
-    )
-
-    return UkFormSection("API Keys", "Manage API keys of your agents", button_txt="Update api keys", *content)
-
-
-def appearance_form():
-    content = (
-        FormSectionDiv(
-            LabelUkSelect(
-                *Options("Select a font family", "Inter", "Geist", "Open Sans", selected_idx=2, disabled_idxs={0}),
-                label="Font Family",
-                id="font_family",
-            ),
-            HelpText("Set the font you want to use in the dashboard."),
-        ),
-        FormSectionDiv(
-            FormLabel("Theme"),
-            HelpText("Select the theme for the dashboard."),
-            ThemeDialog(),
-        ),
-    )
-
-    return UkFormSection(
-        "Appearance",
-        "Customize the appearance of the app. Automatically switch between day and night themes.",
-        button_txt="Update preferences",
-        *content,
-    )
-
-
-def display_form():
-    content = Div(cls="space-y-2")(
-        Div(cls="mb-4")(
-            Span("Sidebar", cls="text-base font-medium"),
-            HelpText("Select the items you want to display in the sidebar."),
-        ),
-        *[
-            Div(CheckboxX(id=f"display_{i}", checked=i in [0, 1, 2]), FormLabel(label))
-            for i, label in enumerate(["Recents", "Home", "Applications", "Desktop", "Downloads", "Documents"])
-        ],
-    )
-    return UkFormSection(
-        "Display", "Turn items on or off to control what's displayed in the app.", button_txt="Update display", *content
-    )
-
-
-def Settings():
-    return Title("Settings form"), Container(
-        heading(),
-        Div(cls="flex gap-x-12")(
-            sidebar,
-            Ul(id="component-nav", cls="uk-switcher max-w-2xl")(
-                Li(cls="uk-active")(api_key_form(), *map(Li, [appearance_form(), display_form()]))
-            ),
-        ),
-    )

flock/core/agent.py

@@ -1,150 +0,0 @@
-from abc import ABC, abstractmethod
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any, Literal, TypeVar
-
-import cloudpickle
-from pydantic import BaseModel, Field
-
-from flock.core.context import FlockContext
-from flock.core.logging import flock_logger, live_update_handler, performance_handler
-from flock.core.serializable import Serializable
-
-T = TypeVar("T", bound="Agent")
-
-
-@dataclass
-class AgentConfig:
-    save_to_file: bool = False
-    data_type: Literal["json", "cloudpickle", "msgpack"] = "cloudpickle"
-
-
-class Agent(Serializable, BaseModel, ABC):
-    """Base class for all agents in the framework.
-
-    Attributes:
-      - name: A unique identifier for the agent.
-      - model: The model identifier (e.g., an LLM specification).
-      - description: A human‑readable description of the agent.
-      - hand_off: Defines the next agent to invoke (can be a string or callable).
-      - termination: (Optional) A termination condition or phrase; can be used in lifecycle hooks.
-
-    Lifecycle Hooks:
-      - initialize(): Called before the agent runs.
-      - terminate(): Called after the agent finishes running.
-
-    Temporal Execution:
-      The default run_temporal() method serializes the agent and the current FlockContext
-      and calls a Temporal activity (run_agent_activity) to perform the execution in a Temporal worker.
-      Subclasses may override run_temporal() if custom behavior is required.
-    """
-
-    name: str = Field(description="Identifier name for the agent")
-    model: str = Field(default="", description="Model of the agent")
-    description: str | Callable[..., str] = Field(default="", description="Description of the agent")
-    # Use a default factory for hand_off so it defaults to an empty list.
-    hand_off: list[str | Callable[..., Any]] = Field(default_factory=list, description="Handoff to another agent")
-    termination: str | None = Field(default=None, description="Optional termination condition or phrase")
-
-    def register(self, registry) -> None:
-        """Register this agent with the provided registry."""
-        registry.register_agent(self)
-
-    @abstractmethod
-    async def run(self, context: FlockContext) -> dict:
-        """Execute the agent's logic locally.
-
-        This method must be implemented by each concrete agent.
-        """
-        pass
-
-    async def run_temporal(self, context: FlockContext) -> dict:
-        """Execute the agent's logic via Temporal."""
-        # Run initialization tasks
-        await self.initialize(context)
-
-        from temporalio.client import Client
-
-        from flock.workflow.agent_activities import run_agent_activity
-        from flock.workflow.temporal_setup import run_activity
-
-        try:
-            with performance_handler.track_time("temporal_connection"):
-                flock_logger.info("Connecting to Temporal service...")
-                client = await Client.connect("localhost:7233", namespace="default")
-
-            # Convert the FlockContext to a serializable dictionary
-            context_data = {
-                "state": context.state,
-                "history": [record.__dict__ for record in context.history],
-                "agent_definitions": [definition.__dict__ for definition in context.agent_definitions],
-            }
-            agent_data = self.dict()
-
-            # Execute the Temporal activity
-            with performance_handler.track_time("temporal_execution"):
-                with live_update_handler.update_workflow_status(self.name, "Running", {"phase": "temporal_activity"}):
-                    result = await run_activity(
-                        client,
-                        self.name,
-                        run_agent_activity,
-                        {"agent_data": agent_data, "context_data": context_data},
-                    )
-
-            flock_logger.success(f"Temporal activity completed: {self.name}")
-            return result
-
-        except Exception as e:
-            flock_logger.error(f"Temporal execution failed: {e}", agent=self.name)
-            raise
-        finally:
-            await self.terminate(context)
-
-    async def initialize(self, context: FlockContext) -> None:
-        """Lifecycle hook for agent initialization."""
-        flock_logger.set_context(workflow_id=context.state.get("workflow_id"))
-        flock_logger.info(f"Initializing agent: {self.name}")
-        flock_logger.debug("Agent configuration", config=self.dict())
-        flock_logger.debug("Context state", state=context.state)
-
-    async def terminate(self, context: FlockContext) -> None:
-        """Lifecycle hook for agent termination."""
-        if self.termination and context.get_variable("init_input") == self.termination:
-            flock_logger.warning(
-                "Termination condition met",
-                condition=self.termination,
-                input=context.get_variable("init_input"),
-            )
-        flock_logger.info(f"Terminating agent: {self.name}")
-
-    def to_dict(self) -> dict[str, Any]:
-        def convert_callable(obj):
-            if callable(obj) and not isinstance(obj, type):
-                return cloudpickle.dumps(obj).hex()  # Serialize functions to hex string
-            if isinstance(obj, list):
-                return [convert_callable(x) for x in obj]
-            if isinstance(obj, dict):
-                return {k: convert_callable(v) for k, v in obj.items()}
-            return obj
-
-        # Use Pydantic's model_dump and handle callables
-        return convert_callable(self.model_dump())
-
-    @classmethod
-    def from_dict(cls: type[T], data: dict[str, Any]) -> T:
-        def convert_callable(obj):
-            if isinstance(obj, str) and len(obj) > 2:
-                try:
-                    # Try to deserialize hex string back to callable
-                    return cloudpickle.loads(bytes.fromhex(obj))
-                except:
-                    return obj
-            if isinstance(obj, list):
-                return [convert_callable(x) for x in obj]
-            if isinstance(obj, dict):
-                return {k: convert_callable(v) for k, v in obj.items()}
-            return obj
-
-        # Convert callable strings back to functions
-        converted = convert_callable(data)
-        return cls(**converted)

flock/core/agent_registry.py

@@ -1,162 +0,0 @@
-from collections.abc import Callable
-
-from flock.core.agent import Agent
-from flock.core.logging import flock_logger, performance_handler
-
-
-class Registry:
-    """Registry for storing and managing agents and tools.
-
-    This singleton class maintains a centralized registry of agents and tools,
-    which is particularly important for Temporal workflows where only basic Python
-    types can be passed between activities.
-    """
-
-    _instance = None
-
-    def __new__(cls):
-        """Singleton pattern implementation."""
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            with performance_handler.track_time("registry_initialization"):
-                flock_logger.info("Initializing new Registry instance")
-                cls._instance._initialize()
-        return cls._instance
-
-    def _initialize(self):
-        """Initialize the registry's storage."""
-        self._agents: list[Agent] = []
-        self._tools: list[tuple[str, Callable]] = []
-        flock_logger.debug("Registry storage initialized")
-
-    def register_tool(self, tool_name: str, tool: Callable) -> None:
-        """Register a tool with the registry.
-
-        Args:
-            tool_name: The name to register the tool under
-            tool: The tool function to register
-        """
-        try:
-            with performance_handler.track_time("tool_registration"):
-                self._tools.append((tool_name, tool))
-                flock_logger.info(f"Registered tool: {tool_name}")
-                flock_logger.debug("Tool details", tool_name=tool_name, tool_type=type(tool).__name__)
-        except Exception as e:
-            flock_logger.error(
-                "Tool registration failed",
-                tool_name=tool_name,
-                error=str(e),
-            )
-            raise
-
-    def register_agent(self, agent: Agent) -> None:
-        """Register an agent with the registry.
-
-        Args:
-            agent: The agent instance to register
-        """
-        try:
-            with performance_handler.track_time("agent_registration"):
-                self._agents.append(agent)
-                flock_logger.info(f"Registered agent: {agent.name}")
-                flock_logger.debug(
-                    "Agent details",
-                    name=agent.name,
-                    type=type(agent).__name__,
-                    model=agent.model,
-                )
-        except Exception as e:
-            flock_logger.error(
-                "Agent registration failed",
-                agent_name=getattr(agent, "name", "unknown"),
-                error=str(e),
-            )
-            raise
-
-    def get_agent(self, name: str) -> Agent | None:
-        """Retrieve an agent by name.
-
-        Args:
-            name: The name of the agent to retrieve
-
-        Returns:
-            The agent instance if found, None otherwise
-        """
-        try:
-            with performance_handler.track_time("agent_retrieval"):
-                for agent in self._agents:
-                    if agent.name == name:
-                        flock_logger.debug(f"Retrieved agent: {name}")
-                        return agent
-
-                flock_logger.warning(f"Agent not found: {name}")
-                return None
-        except Exception as e:
-            flock_logger.error(
-                "Agent retrieval failed",
-                agent_name=name,
-                error=str(e),
-            )
-            raise
-
-    def get_tool(self, name: str) -> Callable | None:
-        """Retrieve a tool by name.
-
-        Args:
-            name: The name of the tool to retrieve
-
-        Returns:
-            The tool function if found, None otherwise
-        """
-        try:
-            with performance_handler.track_time("tool_retrieval"):
-                for tool_name, tool in self._tools:
-                    if tool_name == name:
-                        flock_logger.debug(f"Retrieved tool: {name}")
-                        return tool
-
-                flock_logger.warning(f"Tool not found: {name}")
-                return None
-        except Exception as e:
-            flock_logger.error(
-                "Tool retrieval failed",
-                tool_name=name,
-                error=str(e),
-            )
-            raise
-
-    def get_tools(self, names: list[str] | None) -> list[Callable]:
-        """Retrieve multiple tools by name.
-
-        Args:
-            names: List of tool names to retrieve
-
-        Returns:
-            List of found tool functions (may be empty if none found)
-        """
-        try:
-            with performance_handler.track_time("tools_retrieval"):
-                if not names:
-                    flock_logger.debug("No tool names provided")
-                    return []
-
-                tools = [self.get_tool(name) for name in names]
-                found_tools = [name for name, tool in zip(names, tools) if tool is not None]
-
-                if found_tools:
-                    flock_logger.debug(
-                        "Retrieved tools",
-                        requested=len(names),
-                        found=len(found_tools),
-                    )
-                    return [tool for tool in tools if tool is not None]
-
-                flock_logger.warning("No tools found", requested=names)
-                return []
-        except Exception as e:
-            flock_logger.error(
-                "Tools retrieval failed",
-                tool_names=names,
-                error=str(e),
-            )
-            raise

flock/core/context.py

@@ -1,279 +0,0 @@
-from dataclasses import asdict, dataclass, field
-from datetime import datetime
-from typing import Any, Literal
-
-from flock.core.context_vars import FLOCK_LAST_AGENT, FLOCK_LAST_RESULT
-from flock.core.logging import flock_logger, performance_handler
-from flock.core.serializable import Serializable
-
-
-@dataclass
-class AgentRunRecord:
-    agent: str = field(default="")  # Agent name
-    input_data: dict[str, Any] = field(default_factory=dict)
-    output_data: dict[str, Any] = field(default_factory=dict)
-    timestamp: str = field(default="")
-    hand_off: str = field(default="")  # Next agent name
-
-
-@dataclass
-class AgentDefinition:
-    agent_type: str = field(default="")
-    agent_name: str = field(default="")
-    agent_data: dict = field(default=dict)
-    serializer: Literal["json", "cloudpickle", "msgpack"] = field(default="cloudpickle")
-
-
-@dataclass
-class FlockContext(Serializable):
-    state: dict[str, Any] = field(default_factory=dict)
-    history: list[AgentRunRecord] = field(default_factory=list)
-    agent_definitions: dict[str, AgentDefinition] = field(default_factory=dict)
-    run_id: str = field(default="")
-    workflow_id: str = field(default="")
-    workflow_timestamp: str = field(default="")
-
-    def record(self, agent_name: str, data: dict[str, Any], timestamp: str, hand_off: str) -> None:
-        """Record an agent run and update the state with the agent's output."""
-        try:
-            with performance_handler.track_time("record_agent_run"):
-                flock_logger.info(f"Recording agent run: {agent_name}")
-                record = AgentRunRecord(
-                    agent=agent_name, output_data=data.copy(), timestamp=timestamp, hand_off=hand_off
-                )
-                self.history.append(record)
-                flock_logger.debug(
-                    "Created run record",
-                    agent=agent_name,
-                    output_keys=list(data.keys()),
-                )
-
-                self.set_variable(f"{agent_name}.result", data)
-                self.set_variable(FLOCK_LAST_RESULT, data)
-                self.set_variable(FLOCK_LAST_AGENT, agent_name)
-                flock_logger.debug("Updated context state with agent output")
-
-        except Exception as e:
-            flock_logger.error(
-                "Failed to record agent run",
-                agent=agent_name,
-                error=str(e),
-            )
-            raise
-
-    def get_variable(self, key: str) -> Any:
-        """Get the current value of a state variable."""
-        try:
-            with performance_handler.track_time("get_variable"):
-                value = self.state.get(key)
-                if value is None:
-                    flock_logger.warning(f"Variable not found in state: {key}")
-                else:
-                    flock_logger.debug(f"Retrieved variable: {key}")
-                return value
-        except Exception as e:
-            flock_logger.error(
-                "Failed to get variable",
-                key=key,
-                error=str(e),
-            )
-            raise
-
-    def set_variable(self, key: str, value: Any) -> None:
-        """Set the value of a state variable."""
-        try:
-            with performance_handler.track_time("set_variable"):
-                self.state[key] = value
-                flock_logger.debug(f"Set variable: {key}")
-        except Exception as e:
-            flock_logger.error(
-                "Failed to set variable",
-                key=key,
-                error=str(e),
-            )
-            raise
-
-    def deepcopy(self) -> "FlockContext":
-        """Create a deep copy of the context."""
-        try:
-            with performance_handler.track_time("context_deepcopy"):
-                flock_logger.debug("Creating deep copy of context")
-                copy = FlockContext.from_dict(self.to_dict())
-                flock_logger.debug(
-                    "Context copied",
-                    state_vars=len(copy.state),
-                    history_records=len(copy.history),
-                )
-                return copy
-        except Exception as e:
-            flock_logger.error(
-                "Failed to create context copy",
-                error=str(e),
-            )
-            raise
-
-    def get_agent_history(self, agent_name: str) -> list[AgentRunRecord]:
-        """Return all agent run records for a given agent name."""
-        try:
-            with performance_handler.track_time("get_agent_history"):
-                records = [record for record in self.history if record.agent == agent_name]
-                flock_logger.debug(
-                    f"Retrieved history records for {agent_name}",
-                    count=len(records),
-                )
-                return records
-        except Exception as e:
-            flock_logger.error(
-                "Failed to get history records",
-                agent=agent_name,
-                error=str(e),
-            )
-            raise
-
-    def next_input_for(self, agent) -> Any:
-        """By default, the next input for an agent is taken from the context state.
-
-        If the agent.input is a comma-separated list (e.g., "input1, input2"),
-        this method will return a dictionary with keys for each of the input names,
-        fetching the latest values from the state.
-
-        If only a single input is specified, the raw value is returned.
-        """
-        try:
-            with performance_handler.track_time("next_input_preparation"):
-                flock_logger.info(f"Preparing next input for agent: {agent.name}")
-
-                if hasattr(agent, "input") and isinstance(agent.input, str):
-                    keys = [k.strip() for k in agent.input.split(",") if k.strip()]
-                    flock_logger.debug(f"Input keys: {keys}")
-
-                    if len(keys) == 1:
-                        value = self.get_variable(keys[0])
-                        flock_logger.debug(f"Single input value retrieved for key: {keys[0]}")
-                        return value
-                    else:
-                        values = {key: self.get_variable(key) for key in keys}
-                        flock_logger.debug(f"Multiple input values retrieved for keys: {keys}")
-                        return values
-                else:
-                    # Fallback to "init_input"
-                    flock_logger.debug("No input defined, falling back to init_input")
-                    return self.get_variable("init_input")
-        except Exception as e:
-            flock_logger.error(
-                "Failed to prepare next input",
-                agent=getattr(agent, "name", str(agent)),
-                error=str(e),
-            )
-            raise
-
-    def get_agent_definition(self, agent_name: str) -> AgentDefinition | None:
-        """Get the definition for a specific agent."""
-        try:
-            with performance_handler.track_time("get_agent_definition"):
-                for definition in self.agent_definitions:
-                    if definition.name == agent_name:
-                        flock_logger.debug(f"Retrieved definition for agent: {agent_name}")
-                        return definition
-
-                flock_logger.warning(f"No definition found for agent: {agent_name}")
-                return None
-        except Exception as e:
-            flock_logger.error(
-                "Failed to get agent definition",
-                agent=agent_name,
-                error=str(e),
-            )
-            raise
-
-    def add_agent_definition(self, agent_type: type, agent_name: str, agent_data: Any) -> None:
-        """Add a new agent definition to the context."""
-        try:
-            with performance_handler.track_time("add_agent_definition"):
-                definition = AgentDefinition(
-                    agent_type=agent_type.__name__,
-                    agent_name=agent_name,
-                    agent_data=agent_data,
-                )
-                self.agent_definitions[agent_name] = definition
-                flock_logger.info(
-                    f"Added agent definition",
-                    agent=agent_name,
-                    type=agent_type.__name__,
-                )
-        except Exception as e:
-            flock_logger.error(
-                "Failed to add agent definition",
-                agent=agent_name,
-                type=agent_type.__name__,
-                error=str(e),
-            )
-            raise
-
-    # Allow dict-like access for convenience.
-    def __getitem__(self, key: str) -> Any:
-        value = self.state[key]
-        return value
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.state[key] = value
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert the context to a dictionary for serialization."""
-        try:
-            with performance_handler.track_time("context_to_dict"):
-                flock_logger.debug("Converting context to dictionary")
-
-                def convert(obj):
-                    if isinstance(obj, datetime):
-                        return obj.isoformat()
-                    if hasattr(obj, "__dataclass_fields__"):  # Is a dataclass
-                        return asdict(obj, dict_factory=lambda x: {k: convert(v) for k, v in x})
-                    return obj
-
-                result = convert(asdict(self))
-                flock_logger.debug(
-                    "Context converted to dictionary",
-                    state_size=len(result.get("state", {})),
-                    history_size=len(result.get("history", [])),
-                )
-                return result
-        except Exception as e:
-            flock_logger.error(
-                "Failed to convert context to dictionary",
-                error=str(e),
-            )
-            raise
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "FlockContext":
-        """Create a context instance from a dictionary."""
-        try:
-            with performance_handler.track_time("context_from_dict"):
-                flock_logger.debug("Creating context from dictionary")
-
-                def convert(obj):
-                    if isinstance(obj, dict):
-                        if "timestamp" in obj:  # AgentRunRecord
-                            return AgentRunRecord(**{**obj, "timestamp": datetime.fromisoformat(obj["timestamp"])})
-                        if "agent_type" in obj:  # AgentDefinition
-                            return AgentDefinition(**obj)
-                        return {k: convert(v) for k, v in obj.items()}
-                    if isinstance(obj, list):
-                        return [convert(v) for v in obj]
-                    return obj
-
-                converted = convert(data)
-                context = cls(**converted)
-                flock_logger.debug(
-                    "Created context from dictionary",
-                    state_vars=len(context.state),
-                    history_records=len(context.history),
-                )
-                return context
-        except Exception as e:
-            flock_logger.error(
-                "Failed to create context from dictionary",
-                error=str(e),
-            )
-            raise