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

flock/core/orchestration/flock_initialization.py

@@ -1,149 +0,0 @@
-# src/flock/core/orchestration/flock_initialization.py
-"""Initialization functionality for Flock orchestrator."""
-
-import os
-import uuid
-from typing import TYPE_CHECKING
-
-from opentelemetry.baggage import get_baggage, set_baggage
-
-from flock.core.logging.logging import get_logger
-from flock.core.registry import get_registry
-from flock.core.util.cli_helper import init_console
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-    from flock.core.flock_agent import FlockAgent
-    from flock.core.mcp.flock_mcp_server import FlockMCPServer
-
-logger = get_logger("flock.initialization")
-
-
-class FlockInitialization:
-    """Handles initialization logic for Flock orchestrator."""
-
-    def __init__(self, flock: "Flock"):
-        self.flock = flock
-
-    def setup(
-        self,
-        agents: list["FlockAgent"] | None = None,
-        servers: list["FlockMCPServer"] | None = None,
-    ) -> None:
-        """Handle all initialization side effects and setup."""
-        # Workaround: newer litellm logging tries to import proxy dependencies (apscheduler)
-        # via cold storage logging even for non-proxy usage. Avoid hard dependency by
-        # pre-stubbing the `litellm.proxy.proxy_server` module with a minimal object.
-        self._patch_litellm_proxy_imports()
-        # Register passed servers first (agents may depend on them)
-        if servers:
-            self._register_servers(servers)
-
-        # Register passed agents
-        if agents:
-            self._register_agents(agents)
-
-        # Initialize console if needed for banner
-        if self.flock.show_flock_banner:
-            init_console(clear_screen=True, show_banner=self.flock.show_flock_banner, model=self.flock.model)
-
-        # Set Temporal debug environment variable
-        self._set_temporal_debug_flag()
-
-        # Ensure session ID exists in baggage
-        self._ensure_session_id()
-
-        # Auto-discover components
-        registry = get_registry()
-        registry.discover_and_register_components()
-
-        # Setup Opik if enabled
-        if self.flock.enable_opik:
-            self._setup_opik()
-
-        logger.info(
-            "Flock instance initialized",
-            name=self.flock.name,
-            model=self.flock.model,
-            enable_temporal=self.flock.enable_temporal,
-        )
-
-    def _patch_litellm_proxy_imports(self) -> None:
-        """Stub litellm proxy_server to avoid optional proxy deps when not used.
-
-        Some litellm versions import `litellm.proxy.proxy_server` during standard logging
-        to read `general_settings`, which pulls in optional dependencies like `apscheduler`.
-        We provide a stub so imports succeed but cold storage remains disabled.
-        """
-        try:
-            import sys
-            import types
-
-            if "litellm.proxy.proxy_server" not in sys.modules:
-                stub = types.ModuleType("litellm.proxy.proxy_server")
-                # Minimal surface that cold_storage_handler accesses
-                setattr(stub, "general_settings", {})
-                sys.modules["litellm.proxy.proxy_server"] = stub
-        except Exception as e:
-            # Safe to ignore; worst case litellm will log a warning
-            logger.debug(f"Failed to stub litellm proxy_server: {e}")
-
-    def _register_servers(self, servers: list["FlockMCPServer"]) -> None:
-        """Register servers with the Flock instance."""
-        from flock.core.mcp.flock_mcp_server import (
-            FlockMCPServer as ConcreteFlockMCPServer,
-        )
-
-        for server in servers:
-            if isinstance(server, ConcreteFlockMCPServer):
-                self.flock.add_server(server)
-            else:
-                logger.warning(
-                    f"Item provided in 'servers' list is not a FlockMCPServer: {type(server)}"
-                )
-
-    def _register_agents(self, agents: list["FlockAgent"]) -> None:
-        """Register agents with the Flock instance."""
-        from flock.core.flock_agent import FlockAgent as ConcreteFlockAgent
-
-        for agent in agents:
-            if isinstance(agent, ConcreteFlockAgent):
-                self.flock.add_agent(agent)
-            else:
-                logger.warning(
-                    f"Item provided in 'agents' list is not a FlockAgent: {type(agent)}"
-                )
-
-    def _set_temporal_debug_flag(self) -> None:
-        """Set or remove LOCAL_DEBUG env var based on enable_temporal."""
-        if not self.flock.enable_temporal:
-            if "LOCAL_DEBUG" not in os.environ:
-                os.environ["LOCAL_DEBUG"] = "1"
-                logger.debug("Set LOCAL_DEBUG environment variable for local execution.")
-        elif "LOCAL_DEBUG" in os.environ:
-            del os.environ["LOCAL_DEBUG"]
-            logger.debug("Removed LOCAL_DEBUG environment variable for Temporal execution.")
-
-    def _ensure_session_id(self) -> None:
-        """Ensure a session_id exists in the OpenTelemetry baggage."""
-        session_id = get_baggage("session_id")
-        if not session_id:
-            session_id = str(uuid.uuid4())
-            set_baggage("session_id", session_id)
-            logger.debug(f"Generated new session_id: {session_id}")
-
-    def _setup_opik(self) -> None:
-        """Setup Opik integration."""
-        try:
-            import dspy
-            import opik
-            from opik.integrations.dspy.callback import OpikCallback
-
-            opik.configure(use_local=True, automatic_approvals=True)
-            opik_callback = OpikCallback(project_name=self.flock.name, log_graph=True)
-            dspy.settings.configure(callbacks=[opik_callback])
-            logger.info("Opik integration enabled")
-        except ImportError as e:
-            logger.error(f"Failed to setup Opik integration: {e}")
-            logger.warning("Disabling Opik integration")
-            self.flock.enable_opik = False

flock/core/orchestration/flock_server_manager.py

@@ -1,67 +0,0 @@
-# src/flock/core/orchestration/flock_server_manager.py
-"""Server management functionality for Flock orchestrator."""
-
-from typing import TYPE_CHECKING
-
-from flock.core.flock_server_manager import (
-    FlockServerManager as InternalServerManager,
-)
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-    from flock.core.mcp.flock_mcp_server import FlockMCPServer
-
-logger = get_logger("flock.server_manager")
-
-
-class FlockServerManager:
-    """Handles server lifecycle management for Flock orchestrator."""
-
-    def __init__(self, flock: "Flock"):
-        self.flock = flock
-        # Use the existing internal server manager
-        self._internal_mgr = InternalServerManager()
-
-    def add_server(self, server: "FlockMCPServer") -> "FlockMCPServer":
-        """Adds a server instance to this Flock configuration and registry as well as set it up to be managed by internal manager."""
-        from flock.core.mcp.flock_mcp_server import (
-            FlockMCPServer as ConcreteFlockMCPServer,
-        )
-        from flock.core.registry import get_registry
-
-        registry = get_registry()
-
-        if not isinstance(server, ConcreteFlockMCPServer):
-            raise TypeError("Provided object is not a FlockMCPServer instance.")
-        if not server.config.name:
-            raise ValueError("Server must have a name.")
-
-        if server.config.name in self.flock.servers:
-            raise ValueError(
-                f"Server with this name already exists. Name: '{server.config.name}'"
-            )
-
-        self.flock._servers[server.config.name] = server
-        registry.register_server(server)  # Register globally.
-
-        # Prepare server to be managed by the FlockServerManager
-        logger.info(f"Adding server '{server.config.name}' to managed list.")
-        self._internal_mgr.add_server_sync(server=server)
-        logger.info(f"Server '{server.config.name}' is now on managed list.")
-
-        logger.info(f"Server '{server.config.name}' added to Flock '{self.flock.name}'")
-        return server
-
-    async def __aenter__(self):
-        """Start all managed servers."""
-        return await self._internal_mgr.__aenter__()
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Cleanup all managed servers."""
-        return await self._internal_mgr.__aexit__(exc_type, exc_val, exc_tb)
-
-    @property
-    def servers(self) -> dict[str, "FlockMCPServer"]:
-        """Returns the dictionary of servers managed by this Flock instance."""
-        return self.flock._servers

flock/core/orchestration/flock_web_server.py

@@ -1,117 +0,0 @@
-# src/flock/core/orchestration/flock_web_server.py
-"""Web server and CLI management functionality for Flock orchestrator."""
-
-from collections.abc import Callable, Sequence
-from typing import TYPE_CHECKING, Any
-
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.api.custom_endpoint import FlockEndpoint
-    from flock.core.flock import Flock
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("flock.web_server")
-
-
-class FlockWebServer:
-    """Handles web server and CLI functionality for Flock orchestrator."""
-
-    def __init__(self, flock: "Flock"):
-        self.flock = flock
-
-    def serve(
-        self,
-        host: str = "127.0.0.1",
-        port: int = 8344,
-        server_name: str = "Flock Server",
-        ui: bool = True,
-        chat: bool = False,
-        chat_agent: str | None = None,
-        chat_message_key: str = "message",
-        chat_history_key: str = "history",
-        chat_response_key: str = "response",
-        ui_theme: str | None = None,
-        custom_endpoints: Sequence["FlockEndpoint"]
-        | dict[tuple[str, list[str] | None], Callable[..., Any]]
-        | None = None,
-    ) -> None:
-        """Launch an HTTP server that exposes the core REST API and, optionally, the browser-based UI."""
-        try:
-            from flock.webapp.run import start_unified_server
-        except ImportError:
-            logger.error(
-                "Web application components not found (flock.webapp.run). "
-                "Cannot start HTTP server. Ensure webapp dependencies are installed."
-            )
-            return
-
-        logger.info(
-            f"Attempting to start server for Flock '{self.flock.name}' on {host}:{port}. UI enabled: {ui}"
-        )
-
-        start_unified_server(
-            flock_instance=self.flock,
-            host=host,
-            port=port,
-            server_title=server_name,
-            enable_ui_routes=ui,
-            enable_chat_routes=chat,
-            ui_theme=ui_theme,
-            custom_endpoints=custom_endpoints,
-        )
-
-    def start_api(
-        self,
-        host: str = "127.0.0.1",
-        port: int = 8344,
-        server_name: str = "Flock Server",
-        create_ui: bool = True,
-        ui_theme: str | None = None,
-        custom_endpoints: Sequence["FlockEndpoint"]
-        | dict[tuple[str, list[str] | None], Callable[..., Any]]
-        | None = None,
-    ) -> None:
-        """Deprecated: Use serve() instead."""
-        import warnings
-
-        warnings.warn(
-            "start_api() is deprecated and will be removed in a future release. "
-            "Use serve() instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        # Delegate to the new serve() method (create_ui maps to ui)
-        return self.serve(
-            host=host,
-            port=port,
-            server_name=server_name,
-            ui=create_ui,
-            ui_theme=ui_theme,
-            custom_endpoints=custom_endpoints,
-        )
-
-    def start_cli(
-        self,
-        start_agent: "FlockAgent | str | None" = None,
-        server_name: str = "Flock CLI",
-        show_results: bool = False,
-        edit_mode: bool = False,
-    ) -> None:
-        """Starts an interactive CLI for this Flock instance."""
-        try:
-            from flock.cli.runner import start_flock_cli
-        except ImportError:
-            logger.error(
-                "CLI components not found. Cannot start CLI. "
-                "Ensure CLI dependencies are installed."
-            )
-            return
-
-        logger.info(f"Starting CLI for Flock '{self.flock.name}'...")
-        start_flock_cli(
-            flock=self.flock,  # Pass the Flock instance
-            server_name=server_name,
-            show_results=show_results,
-            edit_mode=edit_mode,
-        )

flock/core/registry/__init__.py

@@ -1,45 +0,0 @@
-# src/flock/core/registry/__init__.py
-"""Modern thread-safe registry system using composition pattern.
-
-This module provides a complete refactor of the FlockRegistry using
-the proven composition pattern from Flock and FlockAgent refactoring.
-"""
-
-
-from flock.core.registry.agent_registry import AgentRegistry
-from flock.core.registry.callable_registry import CallableRegistry
-from flock.core.registry.component_discovery import ComponentDiscovery
-
-# Specialized registry components (for advanced usage)
-from flock.core.registry.component_registry import ComponentRegistry
-from flock.core.registry.config_mapping import ConfigMapping
-from flock.core.registry.decorators import (
-    flock_callable,
-    flock_component,
-    flock_tool,
-    flock_type,
-)
-from flock.core.registry.registry_hub import RegistryHub, get_registry
-from flock.core.registry.server_registry import ServerRegistry
-from flock.core.registry.type_registry import TypeRegistry
-
-__all__ = [
-    # Main API
-    "RegistryHub",
-    "get_registry",
-
-    # Decorators
-    "flock_component",
-    "flock_tool",
-    "flock_callable",
-    "flock_type",
-
-    # Specialized registries (for advanced usage)
-    "ComponentRegistry",
-    "CallableRegistry",
-    "AgentRegistry",
-    "ServerRegistry",
-    "TypeRegistry",
-    "ConfigMapping",
-    "ComponentDiscovery",
-]

flock/core/registry/agent_registry.py

@@ -1,69 +0,0 @@
-# src/flock/core/registry/agent_registry.py
-"""Agent instance registration and lookup functionality."""
-
-import threading
-from typing import TYPE_CHECKING
-
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("registry.agents")
-
-
-class AgentRegistry:
-    """Manages FlockAgent instance registration and lookup with thread safety."""
-
-    def __init__(self, lock: threading.RLock):
-        self._lock = lock
-        self._agents: dict[str, "FlockAgent"] = {}
-
-    def register_agent(self, agent: "FlockAgent", *, force: bool = False) -> None:
-        """Register a FlockAgent instance by its name.
-
-        Args:
-            agent: The agent instance to register.
-            force: If True, allow overwriting an existing **different** agent registered under the same name.
-                   If False and a conflicting registration exists, a ValueError is raised.
-        """
-        if not hasattr(agent, "name") or not agent.name:
-            logger.error("Attempted to register an agent without a valid 'name' attribute.")
-            return
-
-        with self._lock:
-            if agent.name in self._agents and self._agents[agent.name] is not agent:
-                # Same agent already registered → silently ignore; different instance → error/force.
-                if not force:
-                    raise ValueError(
-                        f"Agent '{agent.name}' already registered with a different instance. "
-                        "Pass force=True to overwrite the existing registration."
-                    )
-                logger.warning(f"Overwriting existing agent '{agent.name}' registration due to force=True.")
-
-            self._agents[agent.name] = agent
-            logger.debug(f"Registered agent: {agent.name}")
-
-    def get_agent(self, name: str) -> "FlockAgent | None":
-        """Retrieve a registered FlockAgent instance by name."""
-        with self._lock:
-            agent = self._agents.get(name)
-            if not agent:
-                logger.warning(f"Agent '{name}' not found in registry.")
-            return agent
-
-    def get_all_agent_names(self) -> list[str]:
-        """Return a list of names of all registered agents."""
-        with self._lock:
-            return list(self._agents.keys())
-
-    def get_all_agents(self) -> dict[str, "FlockAgent"]:
-        """Get all registered agents."""
-        with self._lock:
-            return self._agents.copy()
-
-    def clear(self) -> None:
-        """Clear all registered agents."""
-        with self._lock:
-            self._agents.clear()
-            logger.debug("Cleared all registered agents")

flock/core/registry/callable_registry.py

@@ -1,139 +0,0 @@
-# src/flock/core/registry/callable_registry.py
-"""Callable function/method registration and lookup functionality."""
-
-import builtins
-import importlib
-import threading
-from collections.abc import Callable
-from typing import Any
-
-from flock.core.logging.logging import get_logger
-
-logger = get_logger("registry.callables")
-
-
-class CallableRegistry:
-    """Manages callable registration with smart lookup and thread safety."""
-
-    def __init__(self, lock: threading.RLock):
-        self._lock = lock
-        self._callables: dict[str, Callable] = {}
-
-    def register_callable(self, func: Callable, name: str | None = None) -> str | None:
-        """Register a callable (function/method). Returns its path string identifier."""
-        path_str = name or self._get_path_string(func)
-        if not path_str:
-            logger.warning(f"Could not register callable {getattr(func, '__name__', 'unknown')}: Unable to determine path string")
-            return None
-
-        with self._lock:
-            if path_str in self._callables and self._callables[path_str] != func:
-                logger.warning(f"Callable '{path_str}' already registered with a different function. Overwriting.")
-            
-            self._callables[path_str] = func
-            logger.debug(f"Registered callable: '{path_str}' ({getattr(func, '__name__', 'unknown')})")
-            return path_str
-
-    def get_callable(self, name_or_path: str) -> Callable:
-        """Retrieve a callable by its registered name or full path string.
-        
-        Attempts dynamic import if not found directly. Prioritizes exact match,
-        then searches for matches ending with '.{name}'.
-        """
-        # 1. Try exact match first (covers full paths and simple names if registered that way)
-        with self._lock:
-            if name_or_path in self._callables:
-                logger.debug(f"Found callable '{name_or_path}' directly in registry.")
-                return self._callables[name_or_path]
-
-        # 2. If not found, and it looks like a simple name, search registered paths
-        if "." not in name_or_path:
-            with self._lock:
-                matches = []
-                for path_str, func in self._callables.items():
-                    # Check if path ends with ".{simple_name}" or exactly matches simple_name
-                    if path_str == name_or_path or path_str.endswith(f".{name_or_path}"):
-                        matches.append(func)
-
-                if len(matches) == 1:
-                    logger.debug(f"Found unique callable for simple name '{name_or_path}' via path '{self.get_callable_path_string(matches[0])}'.")
-                    return matches[0]
-                elif len(matches) > 1:
-                    # Ambiguous simple name - require full path
-                    found_paths = [self.get_callable_path_string(f) for f in matches]
-                    logger.error(f"Ambiguous callable name '{name_or_path}'. Found matches: {found_paths}. Use full path string for lookup.")
-                    raise KeyError(f"Ambiguous callable name '{name_or_path}'. Use full path string.")
-
-        # 3. Attempt dynamic import if it looks like a full path
-        if "." in name_or_path:
-            logger.debug(f"Callable '{name_or_path}' not in registry cache, attempting dynamic import.")
-            try:
-                module_name, func_name = name_or_path.rsplit(".", 1)
-                module = importlib.import_module(module_name)
-                func = getattr(module, func_name)
-                if callable(func):
-                    self.register_callable(func, name_or_path)  # Cache dynamically imported
-                    logger.info(f"Successfully imported and registered module callable '{name_or_path}'")
-                    return func
-                else:
-                    raise TypeError(f"Dynamically imported object '{name_or_path}' is not callable.")
-            except (ImportError, AttributeError, TypeError) as e:
-                logger.error(f"Failed to dynamically load/find callable '{name_or_path}': {e}", exc_info=False)
-
-        # 4. Handle built-ins if not found yet (might be redundant if simple name check worked)
-        elif name_or_path in builtins.__dict__:
-            func = builtins.__dict__[name_or_path]
-            if callable(func):
-                self.register_callable(func, name_or_path)  # Cache it
-                logger.info(f"Found and registered built-in callable '{name_or_path}'")
-                return func
-
-        # 5. Final failure
-        logger.error(f"Callable '{name_or_path}' not found in registry or via import.")
-        raise KeyError(f"Callable '{name_or_path}' not found.")
-
-    def get_callable_path_string(self, func: Callable) -> str | None:
-        """Get the path string for a callable, registering it if necessary."""
-        # First try to find by direct identity
-        with self._lock:
-            for path_str, registered_func in self._callables.items():
-                if func == registered_func:
-                    logger.debug(f"Found existing path string for callable: '{path_str}'")
-                    return path_str
-
-        # If not found by identity, generate path, register, and return
-        path_str = self.register_callable(func)
-        if path_str:
-            logger.debug(f"Generated and registered new path string for callable: '{path_str}'")
-        else:
-            logger.warning(f"Failed to generate path string for callable {getattr(func, '__name__', 'unknown')}")
-
-        return path_str
-
-    def get_all_callables(self) -> dict[str, Callable]:
-        """Get all registered callables."""
-        with self._lock:
-            return self._callables.copy()
-
-    def clear(self) -> None:
-        """Clear all registered callables."""
-        with self._lock:
-            self._callables.clear()
-            logger.debug("Cleared all registered callables")
-
-    @staticmethod
-    def _get_path_string(obj: Callable | type) -> str | None:
-        """Generate a unique path string 'module.ClassName' or 'module.function_name'."""
-        try:
-            module = obj.__module__
-            name = obj.__name__
-            if module == "builtins":
-                return name
-            # Check if it's nested (basic check, might not cover all edge cases)
-            if "." in name and hasattr(__import__(module).__dict__, name.split(".")[0]):
-                # Likely a nested class/method - serialization might need custom handling or pickle
-                logger.warning(f"Object {name} appears nested in {module}. Path string might be ambiguous.")
-            return f"{module}.{name}"
-        except AttributeError:
-            logger.warning(f"Could not determine module/name for object: {obj}")
-            return None