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

flock/core/registry/component_discovery.py

@@ -1,142 +0,0 @@
-# src/flock/core/registry/component_discovery.py
-"""Component discovery and auto-registration functionality."""
-
-import importlib
-import importlib.util
-import inspect
-import os
-import pkgutil
-import threading
-from dataclasses import is_dataclass
-from typing import TYPE_CHECKING, Any
-
-from pydantic import BaseModel
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.registry.registry_hub import RegistryHub
-    from flock.core.component.agent_component_base import AgentComponent
-
-logger = get_logger("registry.discovery")
-
-
-class ComponentDiscovery:
-    """Handles automatic component discovery and registration."""
-
-    def __init__(self, registry_hub: "RegistryHub"):
-        self.registry_hub = registry_hub
-        self._packages_to_scan = [
-            "flock.tools",
-            "flock.components",  # Updated to use unified components
-        ]
-
-    def discover_and_register_components(self) -> None:
-        """Auto-register components from known core packages."""
-        for package_name in self._packages_to_scan:
-            try:
-                package_spec = importlib.util.find_spec(package_name)
-                if package_spec and package_spec.origin:
-                    package_path_list = [os.path.dirname(package_spec.origin)]
-                    logger.info(f"Recursively scanning for modules in package: {package_name} (path: {package_path_list[0]})")
-
-                    # Use walk_packages to recursively find all modules
-                    for module_loader, module_name, is_pkg in pkgutil.walk_packages(
-                        path=package_path_list,
-                        prefix=package_name + ".",  # Ensures module_name is fully qualified
-                        onerror=lambda name: logger.warning(f"Error importing module {name} during scan.")
-                    ):
-                        if not is_pkg and not module_name.split('.')[-1].startswith("_"):
-                            # We are interested in actual modules, not sub-packages themselves for registration
-                            # And also skip modules starting with underscore (e.g. __main__.py)
-                            try:
-                                logger.debug(f"Attempting to auto-register components from module: {module_name}")
-                                self.register_module_components(module_name)
-                            except ImportError as e:
-                                logger.warning(
-                                    f"Could not auto-register from {module_name}: Module not found or import error: {e}"
-                                )
-                            except Exception as e:  # Catch other potential errors during registration
-                                logger.error(
-                                    f"Unexpected error during auto-registration of {module_name}: {e}",
-                                    exc_info=True
-                                )
-                else:
-                    logger.warning(f"Could not find package spec for '{package_name}' to auto-register components/tools.")
-            except Exception as e:
-                logger.error(f"Error while trying to dynamically register from '{package_name}': {e}", exc_info=True)
-
-    def register_module_components(self, module_or_path: Any) -> None:
-        """Scan a module (object or path string) and automatically register.
-
-        - Functions as callables.
-        - Pydantic Models and Dataclasses as types.
-        - Subclasses of AgentComponent as components.
-        """
-        try:
-            if isinstance(module_or_path, str):
-                module = importlib.import_module(module_or_path)
-            elif inspect.ismodule(module_or_path):
-                module = module_or_path
-            else:
-                logger.error(
-                    f"Invalid input for auto-registration: {module_or_path}. Must be module object or path string."
-                )
-                return
-
-            logger.info(f"Auto-registering components from module: {module.__name__}")
-            registered_count = {"callable": 0, "type": 0, "component": 0}
-
-            for name, obj in inspect.getmembers(module):
-                if name.startswith("_"):
-                    continue  # Skip private/internal
-
-                # Register Functions as Callables
-                if (
-                    inspect.isfunction(obj)
-                    and obj.__module__ == module.__name__
-                ):
-                    if self.registry_hub.callables.register_callable(obj):
-                        registered_count["callable"] += 1
-
-                # Register Classes (Types and Components)
-                elif inspect.isclass(obj) and obj.__module__ == module.__name__:
-                    is_component = False
-                    
-                    # Register as Component if subclass of AgentComponent
-                    try:
-                        from flock.core.component.agent_component_base import AgentComponent
-                        if (
-                            issubclass(obj, AgentComponent)
-                            and self.registry_hub.components.register_component(obj)
-                        ):
-                            registered_count["component"] += 1
-                            is_component = True  # Mark as component
-                    except ImportError:
-                        # AgentComponent not available during setup
-                        pass
-
-                    # Register as Type if Pydantic Model or Dataclass
-                    # A component can also be a type used in signatures
-                    base_model_or_dataclass = isinstance(obj, type) and (
-                        issubclass(obj, BaseModel) or is_dataclass(obj)
-                    )
-                    if (
-                        base_model_or_dataclass
-                        and self.registry_hub.types.register_type(obj)
-                        and not is_component
-                    ):
-                        # Only increment type count if it wasn't already counted as component
-                        registered_count["type"] += 1
-
-            logger.info(
-                f"Auto-registration summary for {module.__name__}: "
-                f"{registered_count['callable']} callables, "
-                f"{registered_count['type']} types, "
-                f"{registered_count['component']} components."
-            )
-
-        except Exception as e:
-            logger.error(
-                f"Error during auto-registration for {module_or_path}: {e}",
-                exc_info=True,
-            )

flock/core/registry/component_registry.py

@@ -1,64 +0,0 @@
-# src/flock/core/registry/component_registry.py
-"""Component class registration and lookup functionality."""
-
-import threading
-from typing import TYPE_CHECKING, Any
-
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.component.agent_component_base import AgentComponent
-
-logger = get_logger("registry.components")
-
-
-class ComponentRegistry:
-    """Manages component class registration and lookup with thread safety."""
-
-    def __init__(self, lock: threading.RLock):
-        self._lock = lock
-        self._components: dict[str, type] = {}
-
-    def register_component(self, component_class: type, name: str | None = None) -> str | None:
-        """Register a component class (evaluation, routing, utility components)."""
-        type_name = name or component_class.__name__
-        if not type_name:
-            logger.error(f"Could not determine name for component class: {component_class}")
-            return None
-
-        with self._lock:
-            if type_name in self._components and self._components[type_name] != component_class:
-                logger.warning(f"Component class '{type_name}' already registered. Overwriting.")
-            
-            self._components[type_name] = component_class
-            logger.debug(f"Registered component class: {type_name}")
-            return type_name
-
-    def get_component(self, type_name: str) -> type:
-        """Retrieve a component class by its type name."""
-        with self._lock:
-            if type_name in self._components:
-                return self._components[type_name]
-            
-            logger.error(f"Component class '{type_name}' not found in registry.")
-            raise KeyError(f"Component class '{type_name}' not found. Ensure it is registered.")
-
-    def get_component_type_name(self, component_class: type) -> str | None:
-        """Get the type name for a component class, registering it if necessary."""
-        with self._lock:
-            for type_name, registered_class in self._components.items():
-                if component_class == registered_class:
-                    return type_name
-            # If not found, register using class name and return
-            return self.register_component(component_class)
-
-    def get_all_components(self) -> dict[str, type]:
-        """Get all registered components."""
-        with self._lock:
-            return self._components.copy()
-
-    def clear(self) -> None:
-        """Clear all registered components."""
-        with self._lock:
-            self._components.clear()
-            logger.debug("Cleared all registered components")

flock/core/registry/config_mapping.py

@@ -1,64 +0,0 @@
-# src/flock/core/registry/config_mapping.py
-"""Config-to-component mapping functionality."""
-
-import threading
-from typing import TypeVar
-
-from pydantic import BaseModel
-from flock.core.logging.logging import get_logger
-
-logger = get_logger("registry.config_mapping")
-
-ConfigType = TypeVar("ConfigType", bound=BaseModel)
-ClassType = TypeVar("ClassType", bound=type)
-
-# Global config mapping with thread safety
-_component_config_map: dict[type[BaseModel], type] = {}
-_config_map_lock = threading.RLock()
-
-
-class ConfigMapping:
-    """Manages config-to-component mappings with thread safety."""
-
-    def __init__(self, lock: threading.RLock):
-        self._lock = lock
-
-    def register_config_component_pair(
-        self, config_cls: type[ConfigType], component_cls: type[ClassType]
-    ) -> None:
-        """Explicitly register the mapping between a config and component class."""
-        # Component config validation can be added here if needed
-        # Add more checks if needed (e.g., component_cls inherits from Module/Router/Evaluator)
-
-        with _config_map_lock:
-            if (
-                config_cls in _component_config_map
-                and _component_config_map[config_cls] != component_cls
-            ):
-                logger.warning(
-                    f"Config class {config_cls.__name__} already mapped to {_component_config_map[config_cls].__name__}. "
-                    f"Overwriting with {component_cls.__name__}."
-                )
-
-            _component_config_map[config_cls] = component_cls
-            logger.debug(
-                f"Registered config mapping: {config_cls.__name__} -> {component_cls.__name__}"
-            )
-
-    def get_component_class_for_config(
-        self, config_cls: type[ConfigType]
-    ) -> type[ClassType] | None:
-        """Look up the Component Class associated with a Config Class."""
-        with _config_map_lock:
-            return _component_config_map.get(config_cls)
-
-    def get_all_config_mappings(self) -> dict[type[BaseModel], type]:
-        """Get all config-to-component mappings."""
-        with _config_map_lock:
-            return _component_config_map.copy()
-
-    def clear_config_mappings(self) -> None:
-        """Clear all config-to-component mappings."""
-        with _config_map_lock:
-            _component_config_map.clear()
-            logger.debug("Cleared all config-to-component mappings")

flock/core/registry/decorators.py

@@ -1,137 +0,0 @@
-# src/flock/core/registry/decorators.py
-"""Registry decorators for component, tool, and type registration."""
-
-import inspect
-from collections.abc import Callable
-from typing import Any, TypeVar, overload
-
-from flock.core.registry.registry_hub import get_registry
-
-ClassType = TypeVar("ClassType", bound=type)
-FuncType = TypeVar("FuncType", bound=Callable)
-ConfigType = TypeVar("ConfigType")
-
-
-# --- Component Registration Decorator ---
-
-@overload
-def flock_component(cls: ClassType) -> ClassType: ...  # Basic registration
-
-
-@overload
-def flock_component(
-    *, name: str | None = None, config_class: type[ConfigType] | None = None
-) -> Callable[[ClassType], ClassType]: ...  # With options
-
-
-def flock_component(
-    cls: ClassType | None = None,
-    *,
-    name: str | None = None,
-    config_class: type[ConfigType] | None = None,
-) -> Any:
-    """Decorator to register a Flock Component class and optionally link its config class."""
-    registry = get_registry()
-
-    def decorator(inner_cls: ClassType) -> ClassType:
-        if not inspect.isclass(inner_cls):
-            raise TypeError("@flock_component can only decorate classes.")
-
-        component_name = name or inner_cls.__name__
-        registry.register_component(inner_cls, name=component_name)
-
-        # If config_class is provided, register the mapping
-        if config_class:
-            registry.register_config_component_pair(config_class, inner_cls)
-
-        return inner_cls
-
-    if cls is None:
-        # Called as @flock_component(name="...", config_class=...)
-        return decorator
-    else:
-        # Called as @flock_component
-        return decorator(cls)
-
-
-# --- Tool/Callable Registration Decorator ---
-
-@overload
-def flock_tool(func: FuncType) -> FuncType: ...
-
-
-@overload
-def flock_tool(
-    *, name: str | None = None
-) -> Callable[[FuncType], FuncType]: ...
-
-
-def flock_tool(func: FuncType | None = None, *, name: str | None = None) -> Any:
-    """Decorator to register a callable function/method as a Tool (or general callable).
-
-    Usage:
-        @flock_tool
-        def my_web_search(query: str): ...
-
-        @flock_tool(name="utils.calculate_pi")
-        def compute_pi(): ...
-    """
-    registry = get_registry()
-
-    def decorator(inner_func: FuncType) -> FuncType:
-        if not callable(inner_func):
-            raise TypeError("@flock_tool can only decorate callables.")
-        # Let registry handle default name generation if None
-        registry.register_callable(inner_func, name=name)
-        return inner_func
-
-    if func is None:
-        # Called as @flock_tool(name="...")
-        return decorator
-    else:
-        # Called as @flock_tool
-        return decorator(func)
-
-
-# Alias for clarity
-flock_callable = flock_tool
-
-
-# --- Type Registration Decorator ---
-
-@overload
-def flock_type(cls: ClassType) -> ClassType: ...
-
-
-@overload
-def flock_type(
-    *, name: str | None = None
-) -> Callable[[ClassType], ClassType]: ...
-
-
-def flock_type(cls: ClassType | None = None, *, name: str | None = None) -> Any:
-    """Decorator to register a Type (Pydantic Model, Dataclass) used in signatures.
-
-    Usage:
-        @flock_type
-        class MyDataModel(BaseModel): ...
-
-        @flock_type(name="UserInput")
-        @dataclass
-        class UserQuery: ...
-    """
-    registry = get_registry()
-
-    def decorator(inner_cls: ClassType) -> ClassType:
-        if not inspect.isclass(inner_cls):
-            raise TypeError("@flock_type can only decorate classes.")
-        type_name = name or inner_cls.__name__
-        registry.register_type(inner_cls, name=type_name)
-        return inner_cls
-
-    if cls is None:
-        # Called as @flock_type(name="...")
-        return decorator
-    else:
-        # Called as @flock_type
-        return decorator(cls)

flock/core/registry/registry_hub.py

@@ -1,205 +0,0 @@
-# src/flock/core/registry/registry_hub.py
-"""Main registry hub using composition pattern with thread safety."""
-
-import threading
-from typing import TYPE_CHECKING, Any, TypeVar
-
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from flock.core.flock_agent import FlockAgent
-    from flock.core.mcp.flock_mcp_server import FlockMCPServer
-
-logger = get_logger("registry.hub")
-
-T = TypeVar("T")
-ConfigType = TypeVar("ConfigType")
-ClassType = TypeVar("ClassType")
-
-
-class RegistryHub:
-    """Thread-safe registry hub using composition pattern.
-    
-    Main coordinator for all registry types following the successful
-    pattern from Flock and FlockAgent refactoring.
-    """
-
-    def __init__(self):
-        self._lock = threading.RLock()
-        logger.debug("RegistryHub initialized with thread safety")
-
-    # --- Lazy-loaded composition helpers (following Flock pattern) ---
-
-    @property
-    def components(self):
-        """Component class registry helper."""
-        if not hasattr(self, '_components_helper'):
-            from flock.core.registry.component_registry import ComponentRegistry
-            self._components_helper = ComponentRegistry(self._lock)
-        return self._components_helper
-
-    @property
-    def callables(self):
-        """Callable registry helper."""
-        if not hasattr(self, '_callables_helper'):
-            from flock.core.registry.callable_registry import CallableRegistry
-            self._callables_helper = CallableRegistry(self._lock)
-        return self._callables_helper
-
-    @property
-    def agents(self):
-        """Agent registry helper."""
-        if not hasattr(self, '_agents_helper'):
-            from flock.core.registry.agent_registry import AgentRegistry
-            self._agents_helper = AgentRegistry(self._lock)
-        return self._agents_helper
-
-    @property
-    def servers(self):
-        """Server registry helper."""
-        if not hasattr(self, '_servers_helper'):
-            from flock.core.registry.server_registry import ServerRegistry
-            self._servers_helper = ServerRegistry(self._lock)
-        return self._servers_helper
-
-    @property
-    def types(self):
-        """Type registry helper."""
-        if not hasattr(self, '_types_helper'):
-            from flock.core.registry.type_registry import TypeRegistry
-            self._types_helper = TypeRegistry(self._lock)
-        return self._types_helper
-
-    @property
-    def config_mapping(self):
-        """Config mapping helper."""
-        if not hasattr(self, '_config_mapping_helper'):
-            from flock.core.registry.config_mapping import ConfigMapping
-            self._config_mapping_helper = ConfigMapping(self._lock)
-        return self._config_mapping_helper
-
-    @property
-    def discovery(self):
-        """Component discovery helper."""
-        if not hasattr(self, '_discovery_helper'):
-            from flock.core.registry.component_discovery import (
-                ComponentDiscovery,
-            )
-            self._discovery_helper = ComponentDiscovery(self)
-        return self._discovery_helper
-
-    # --- High-level registry operations (delegate to helpers) ---
-
-    def register_agent(self, agent: "FlockAgent", *, force: bool = False) -> None:
-        """Register a FlockAgent instance."""
-        self.agents.register_agent(agent, force=force)
-
-    def get_agent(self, name: str) -> "FlockAgent | None":
-        """Get a registered FlockAgent instance by name."""
-        return self.agents.get_agent(name)
-
-    def get_all_agent_names(self) -> list[str]:
-        """Get all registered agent names."""
-        return self.agents.get_all_agent_names()
-
-    def register_server(self, server: "FlockMCPServer") -> None:
-        """Register a FlockMCPServer instance."""
-        self.servers.register_server(server)
-
-    def get_server(self, name: str) -> "FlockMCPServer | None":
-        """Get a registered FlockMCPServer instance by name."""
-        return self.servers.get_server(name)
-
-    def get_all_server_names(self) -> list[str]:
-        """Get all registered server names."""
-        return self.servers.get_all_server_names()
-
-    def register_callable(self, func: "Callable", name: str | None = None) -> str | None:
-        """Register a callable function/method."""
-        return self.callables.register_callable(func, name)
-
-    def get_callable(self, name_or_path: str) -> "Callable":
-        """Get a registered callable by name or path."""
-        return self.callables.get_callable(name_or_path)
-
-    def get_callable_path_string(self, func: "Callable") -> str | None:
-        """Get the path string for a callable."""
-        return self.callables.get_callable_path_string(func)
-
-    def register_type(self, type_obj: type, name: str | None = None) -> str | None:
-        """Register a type (Pydantic Model, Dataclass, etc.)."""
-        return self.types.register_type(type_obj, name)
-
-    def get_type(self, type_name: str) -> type:
-        """Get a registered type by name."""
-        return self.types.get_type(type_name)
-
-    def register_component(self, component_class: type, name: str | None = None) -> str | None:
-        """Register a component class."""
-        return self.components.register_component(component_class, name)
-
-    def get_component(self, type_name: str) -> type:
-        """Get a registered component class by name."""
-        return self.components.get_component(type_name)
-
-    def get_component_type_name(self, component_class: type) -> str | None:
-        """Get the type name for a component class."""
-        return self.components.get_component_type_name(component_class)
-
-    def register_config_component_pair(self, config_cls: type[ConfigType], component_cls: type[ClassType]) -> None:
-        """Register a config-to-component mapping."""
-        self.config_mapping.register_config_component_pair(config_cls, component_cls)
-
-    def get_component_class_for_config(self, config_cls: type[ConfigType]) -> type[ClassType] | None:
-        """Get the component class for a config class."""
-        return self.config_mapping.get_component_class_for_config(config_cls)
-
-    def discover_and_register_components(self) -> None:
-        """Auto-discover and register components from known packages."""
-        self.discovery.discover_and_register_components()
-
-    def register_module_components(self, module_or_path: Any) -> None:
-        """Register components from a specific module."""
-        self.discovery.register_module_components(module_or_path)
-
-    # --- Utility methods ---
-
-    def clear_all(self) -> None:
-        """Clear all registries (useful for testing)."""
-        with self._lock:
-            if hasattr(self, '_agents_helper'):
-                self.agents.clear()
-            if hasattr(self, '_servers_helper'):
-                self.servers.clear()
-            if hasattr(self, '_callables_helper'):
-                self.callables.clear()
-            if hasattr(self, '_types_helper'):
-                self.types.clear()
-            if hasattr(self, '_components_helper'):
-                self.components.clear()
-            if hasattr(self, '_config_mapping_helper'):
-                self.config_mapping.clear_config_mappings()
-            logger.debug("Cleared all registries")
-
-    def get_registry_summary(self) -> dict[str, int]:
-        """Get a summary of all registries."""
-        with self._lock:
-            return {
-                "agents": len(self.agents.get_all_agents()),
-                "servers": len(self.servers.get_all_servers()),
-                "callables": len(self.callables.get_all_callables()),
-                "types": len(self.types.get_all_types()),
-                "components": len(self.components.get_all_components()),
-                "config_mappings": len(self.config_mapping.get_all_config_mappings()),
-            }
-
-
-# --- Global singleton instance ---
-_default_registry_hub = RegistryHub()
-
-
-def get_registry() -> RegistryHub:
-    """Get the default thread-safe registry hub instance."""
-    return _default_registry_hub

flock/core/registry/server_registry.py

@@ -1,57 +0,0 @@
-# src/flock/core/registry/server_registry.py
-"""MCP Server 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.mcp.flock_mcp_server import FlockMCPServer
-
-logger = get_logger("registry.servers")
-
-
-class ServerRegistry:
-    """Manages FlockMCPServerBase registration and lookup with thread safety."""
-
-    def __init__(self, lock: threading.RLock):
-        self._lock = lock
-        self._servers: dict[str, FlockMCPServer] = {}
-
-    def register_server(self, server: "FlockMCPServer") -> None:
-        """Register a flock mcp server by its name."""
-        if not hasattr(server.config, "name") or not server.config.name:
-            logger.error("Attempted to register a server without a valid 'name' attribute.")
-            return
-
-        with self._lock:
-            if server.config.name in self._servers and self._servers[server.config.name] != server:
-                logger.warning(f"Server '{server.config.name}' already registered. Overwriting.")
-
-            self._servers[server.config.name] = server
-            logger.debug(f"Registered server: {server.config.name}")
-
-    def get_server(self, name: str) -> "FlockMCPServer | None":
-        """Retrieve a registered FlockMCPServer instance by name."""
-        with self._lock:
-            server = self._servers.get(name)
-            if not server:
-                logger.warning(f"Server '{name}' not found in registry.")
-            return server
-
-    def get_all_server_names(self) -> list[str]:
-        """Return a list of names for all registered servers."""
-        with self._lock:
-            return list(self._servers.keys())
-
-    def get_all_servers(self) -> dict[str, "FlockMCPServer"]:
-        """Get all registered servers."""
-        with self._lock:
-            return self._servers.copy()
-
-    def clear(self) -> None:
-        """Clear all registered servers."""
-        with self._lock:
-            self._servers.clear()
-            logger.debug("Cleared all registered servers")