provide-foundation 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev2__py3-none-any.whl

provide/foundation/hub/components.py

@@ -6,22 +6,18 @@ components are managed through the Hub registry system. Provides centralized
 component discovery, lifecycle management, and dependency resolution.
 """
 
-import asyncio
-from enum import Enum
-import inspect
 import threading
-from typing import Any, Protocol, TypeVar
+from enum import Enum
+from typing import Any, Protocol
 
 from attrs import define, field
 
-from provide.foundation.hub.registry import Registry, RegistryEntry
+from provide.foundation.errors.decorators import with_error_handling
+from provide.foundation.hub.registry import Registry
 from provide.foundation.logger import get_logger
-from provide.foundation.eventsets.types import EventMapping
 
 log = get_logger(__name__)
 
-T = TypeVar("T")
-
 
 @define(frozen=True, slots=True)
 class ComponentInfo:
@@ -75,191 +71,19 @@ def get_component_registry() -> Registry:
     return _component_registry
 
 
-
-def resolve_config_value(key: str) -> Any:
-    """Resolve configuration value using priority-ordered sources."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Get all config sources
-        all_entries = list(registry)
-        config_sources = [
-            entry
-            for entry in all_entries
-            if entry.dimension == ComponentCategory.CONFIG_SOURCE.value
-        ]
-
-        # Sort by priority (highest first)
-        config_sources.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
-
-        # Try each source
-        for entry in config_sources:
-            source = entry.value
-            if hasattr(source, "get_value"):
-                try:
-                    value = source.get_value(key)
-                    if value is not None:
-                        return value
-                except Exception:
-                    continue
-
-        return None
-
-
-def get_config_chain() -> list[RegistryEntry]:
-    """Get configuration sources ordered by priority."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Get all config sources
-        all_entries = list(registry)
-        config_sources = [
-            entry
-            for entry in all_entries
-            if entry.dimension == ComponentCategory.CONFIG_SOURCE.value
-        ]
-
-        # Sort by priority (highest first)
-        config_sources.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
-        return config_sources
-
-
-async def load_all_configs() -> dict[str, Any]:
-    """Load configurations from all registered sources."""
-    configs = {}
-    chain = get_config_chain()
-
-    for entry in chain:
-        source = entry.value
-        if hasattr(source, "load_config"):
-            try:
-                if inspect.iscoroutinefunction(source.load_config):
-                    source_config = await source.load_config()
-                else:
-                    source_config = source.load_config()
-
-                if source_config:
-                    configs.update(source_config)
-            except Exception as e:
-                log.warning(
-                    "Config source failed to load", source=entry.name, error=str(e)
-                )
-
-    return configs
-
-
-def get_processor_pipeline() -> list[RegistryEntry]:
-    """Get log processors ordered by priority."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Get all processors
-        all_entries = list(registry)
-        processors = [
-            entry
-            for entry in all_entries
-            if entry.dimension == ComponentCategory.PROCESSOR.value
-        ]
-
-        # Sort by priority (highest first)
-        processors.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
-        return processors
-
-
-def get_processors_for_stage(stage: str) -> list[RegistryEntry]:
-    """Get processors for a specific processing stage."""
-    pipeline = get_processor_pipeline()
-    return [entry for entry in pipeline if entry.metadata.get("stage") == stage]
-
-
-def get_handlers_for_exception(exception: Exception) -> list[RegistryEntry]:
-    """Get error handlers that can handle the given exception type."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        # Get all error handlers
-        all_entries = list(registry)
-        handlers = [
-            entry
-            for entry in all_entries
-            if entry.dimension == ComponentCategory.ERROR_HANDLER.value
-        ]
-
-        # Filter by exception type
-        exception_type_name = type(exception).__name__
-        matching_handlers = []
-
-        for entry in handlers:
-            exception_types = entry.metadata.get("exception_types", [])
-            if any(
-                exc_type in exception_type_name or exception_type_name in exc_type
-                for exc_type in exception_types
-            ):
-                matching_handlers.append(entry)
-
-        # Sort by priority (highest first)
-        matching_handlers.sort(
-            key=lambda e: e.metadata.get("priority", 0), reverse=True
-        )
-        return matching_handlers
-
-
-def execute_error_handlers(
-    exception: Exception, context: dict[str, Any]
-) -> dict[str, Any] | None:
-    """Execute error handlers until one handles the exception."""
-    handlers = get_handlers_for_exception(exception)
-
-    for entry in handlers:
-        handler = entry.value
-        try:
-            result = handler(exception, context)
-            if result is not None:
-                return result
-        except Exception as handler_error:
-            log.error(
-                "Error handler failed", handler=entry.name, error=str(handler_error)
-            )
-
-    return None
-
-
-def resolve_component_dependencies(name: str, dimension: str) -> dict[str, Any]:
-    """Resolve component dependencies recursively."""
-    with _registry_lock:
-        registry = get_component_registry()
-        entry = registry.get_entry(name, dimension)
-
-        if not entry:
-            return {}
-
-        dependencies = {}
-        dep_names = entry.metadata.get("dependencies", [])
-
-        for dep_name in dep_names:
-            # Try same dimension first
-            dep_component = registry.get(dep_name, dimension)
-            if dep_component is not None:
-                dependencies[dep_name] = dep_component
-            else:
-                # Search across dimensions
-                dep_component = registry.get(dep_name)
-                if dep_component is not None:
-                    dependencies[dep_name] = dep_component
-
-        return dependencies
-
-
+@with_error_handling(
+    fallback={"status": "error"},
+    context_provider=lambda: {"function": "check_component_health", "module": "hub.components"}
+)
 def check_component_health(name: str, dimension: str) -> dict[str, Any]:
     """Check component health status."""
     with _registry_lock:
-        registry = get_component_registry()
-        component = registry.get(name, dimension)
+        component = _component_registry.get(name, dimension)
 
         if not component:
             return {"status": "not_found"}
 
-        entry = registry.get_entry(name, dimension)
+        entry = _component_registry.get_entry(name, dimension)
         if not entry.metadata.get("supports_health_check", False):
             return {"status": "no_health_check"}
 
@@ -275,8 +99,7 @@ def check_component_health(name: str, dimension: str) -> dict[str, Any]:
 def get_component_config_schema(name: str, dimension: str) -> dict[str, Any] | None:
     """Get component configuration schema."""
     with _registry_lock:
-        registry = get_component_registry()
-        entry = registry.get_entry(name, dimension)
+        entry = _component_registry.get_entry(name, dimension)
 
         if not entry:
             return None
@@ -284,149 +107,10 @@ def get_component_config_schema(name: str, dimension: str) -> dict[str, Any] | N
         return entry.metadata.get("config_schema")
 
 
-def get_or_initialize_component(name: str, dimension: str) -> Any:
-    """Get component, initializing lazily if needed."""
-    with _registry_lock:
-        key = (name, dimension)
-
-        # Return already initialized component
-        if key in _initialized_components:
-            return _initialized_components[key]
-
-        registry = get_component_registry()
-        entry = registry.get_entry(name, dimension)
-
-        if not entry:
-            return None
-
-        # If already initialized, return it
-        if entry.value is not None:
-            _initialized_components[key] = entry.value
-            return entry.value
-
-        # Initialize lazily
-        if entry.metadata.get("lazy", False):
-            factory = entry.metadata.get("factory")
-            if factory:
-                try:
-                    component = factory()
-                    # Update registry with initialized component
-                    registry.register(
-                        name=name,
-                        value=component,
-                        dimension=dimension,
-                        metadata=entry.metadata,
-                        replace=True,
-                    )
-                    _initialized_components[key] = component
-                    return component
-                except Exception as e:
-                    log.error(
-                        "Component initialization failed",
-                        component=name,
-                        dimension=dimension,
-                        error=str(e),
-                    )
-
-        return entry.value
-
-
-async def initialize_async_component(name: str, dimension: str) -> Any:
-    """Initialize component asynchronously."""
-    with _registry_lock:
-        key = (name, dimension)
-
-        # Return already initialized component
-        if key in _initialized_components:
-            return _initialized_components[key]
-
-        registry = get_component_registry()
-        entry = registry.get_entry(name, dimension)
-
-        if not entry:
-            return None
-
-        # Initialize with async factory
-        if entry.metadata.get("async", False):
-            factory = entry.metadata.get("factory")
-            if factory:
-                try:
-                    if inspect.iscoroutinefunction(factory):
-                        component = await factory()
-                    else:
-                        component = factory()
-
-                    # Update registry
-                    registry.register(
-                        name=name,
-                        value=component,
-                        dimension=dimension,
-                        metadata=entry.metadata,
-                        replace=True,
-                    )
-                    _initialized_components[key] = component
-                    return component
-                except Exception as e:
-                    log.error(
-                        "Async component initialization failed",
-                        component=name,
-                        dimension=dimension,
-                        error=str(e),
-                    )
-
-        return entry.value
-
-
-def cleanup_all_components(dimension: str | None = None) -> None:
-    """Clean up all components in dimension."""
-    with _registry_lock:
-        registry = get_component_registry()
-
-        if dimension:
-            entries = [entry for entry in registry if entry.dimension == dimension]
-        else:
-            entries = list(registry)
-
-        for entry in entries:
-            if entry.metadata.get("supports_cleanup", False):
-                component = entry.value
-                if hasattr(component, "cleanup"):
-                    try:
-                        cleanup_func = component.cleanup
-                        if inspect.iscoroutinefunction(cleanup_func):
-                            # Run async cleanup
-                            loop = None
-                            try:
-                                loop = asyncio.get_event_loop()
-                                if loop.is_running():
-                                    # Create task if loop is running
-                                    loop.create_task(cleanup_func())
-                                else:
-                                    loop.run_until_complete(cleanup_func())
-                            except RuntimeError:
-                                # Create new loop if none exists
-                                loop = asyncio.new_event_loop()
-                                loop.run_until_complete(cleanup_func())
-                                loop.close()
-                        else:
-                            cleanup_func()
-                    except Exception as e:
-                        log.error(
-                            "Component cleanup failed",
-                            component=entry.name,
-                            dimension=entry.dimension,
-                            error=str(e),
-                        )
-
-
 def bootstrap_foundation() -> None:
     """Bootstrap Foundation with core registry components."""
     registry = get_component_registry()
 
-    # Event sets are now managed by the eventsets module
-
-    # Config sources would be registered here when implemented
-
     # Register core processors
     def timestamp_processor(logger, method_name, event_dict):
         import time
@@ -444,71 +128,75 @@ def bootstrap_foundation() -> None:
     log.debug("Foundation bootstrap completed with registry components")
 
 
-def load_config_from_registry(config_class: type[T]) -> T:
-    """Load configuration using registered config sources."""
-    configs = {}
-
-    # Use sync version for now - async version needs event loop handling
-    chain = get_config_chain()
-    for entry in chain:
-        source = entry.value
-        if hasattr(source, "load_config"):
-            try:
-                if not inspect.iscoroutinefunction(source.load_config):
-                    source_config = source.load_config()
-                    if source_config:
-                        configs.update(source_config)
-            except Exception as e:
-                log.warning("Config source failed", source=entry.name, error=str(e))
-
-    return config_class.from_dict(configs)
-
-
-async def initialize_all_async_components() -> None:
-    """Initialize all async components in dependency order."""
-    registry = get_component_registry()
-
-    # Get all async components
-    async_components = [
-        entry for entry in registry if entry.metadata.get("async", False)
-    ]
-
-    # Sort by priority for initialization order
-    async_components.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
-
-    # Initialize each component
-    for entry in async_components:
-        try:
-            await initialize_async_component(entry.name, entry.dimension)
-        except Exception as e:
-            log.error(
-                "Failed to initialize async component",
-                component=entry.name,
-                dimension=entry.dimension,
-                error=str(e),
-            )
-
-
 def reset_registry_for_tests() -> None:
-    """Reset registry state for test isolation."""
+    """Reset registry state for testing."""
+    global _initialized_components
     with _registry_lock:
-        global _initialized_components
         _component_registry.clear()
         _initialized_components.clear()
 
 
-def discover_components(
-    group: str,
-    dimension: str = "component",
-    registry: Registry | None = None,
-) -> dict[str, type[Any]]:
-    """
-    Discover and register components from entry points.
+# Import and re-export functions from specialized modules
+from provide.foundation.hub.config import (
+    resolve_config_value,
+    get_config_chain,
+    load_all_configs,
+    load_config_from_registry,
+)
+
+from provide.foundation.hub.handlers import (
+    get_handlers_for_exception,
+    execute_error_handlers,
+)
 
-    This is a stub for the TDD implementation.
-    """
-    return {}
+from provide.foundation.hub.lifecycle import (
+    get_or_initialize_component,
+    initialize_async_component,
+    cleanup_all_components,
+    initialize_all_async_components,
+)
+
+from provide.foundation.hub.processors import (
+    get_processor_pipeline,
+    get_processors_for_stage,
+)
+
+from provide.foundation.hub.discovery import (
+    resolve_component_dependencies,
+    discover_components,
+)
 
 
 # Bootstrap on module import
 bootstrap_foundation()
+
+
+__all__ = [
+    # Core classes
+    "ComponentInfo",
+    "ComponentCategory", 
+    "ComponentLifecycle",
+    # Registry access
+    "get_component_registry",
+    # Health and schema
+    "check_component_health",
+    "get_component_config_schema",
+    # Bootstrap and testing
+    "bootstrap_foundation",
+    "reset_registry_for_tests",
+    # Re-exported from specialized modules
+    "resolve_config_value",
+    "get_config_chain",
+    "load_all_configs",
+    "load_config_from_registry",
+    "get_handlers_for_exception", 
+    "execute_error_handlers",
+    "get_or_initialize_component",
+    "initialize_async_component",
+    "cleanup_all_components",
+    "initialize_all_async_components",
+    "get_processor_pipeline",
+    "get_processors_for_stage",
+    "resolve_component_dependencies",
+    "discover_components",
+]

provide/foundation/hub/config.py

@@ -0,0 +1,151 @@
+"""
+Hub configuration management utilities.
+
+Provides functions for resolving configuration values from registered sources,
+loading configurations, and managing the configuration chain.
+"""
+
+import asyncio
+import inspect
+from typing import Any, TypeVar
+
+from provide.foundation.errors.decorators import with_error_handling
+from provide.foundation.hub.registry import RegistryEntry
+from provide.foundation.logger import get_logger
+
+T = TypeVar("T")
+
+log = get_logger(__name__)
+
+
+def _get_registry_and_lock():
+    """Get registry and lock from components module."""
+    from provide.foundation.hub.components import get_component_registry, _registry_lock, ComponentCategory
+    return get_component_registry(), _registry_lock, ComponentCategory
+
+
+@with_error_handling(fallback=None, suppress=(Exception,))
+def resolve_config_value(key: str) -> Any:
+    """Resolve configuration value using priority-ordered sources."""
+    registry, registry_lock, ComponentCategory = _get_registry_and_lock()
+    
+    with registry_lock:
+        # Get all config sources
+        all_entries = list(registry)
+        config_sources = [
+            entry
+            for entry in all_entries
+            if entry.dimension == ComponentCategory.CONFIG_SOURCE.value
+        ]
+
+        # Sort by priority (highest first)
+        config_sources.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
+
+        # Try each source
+        for entry in config_sources:
+            source = entry.value
+            if hasattr(source, "get_value"):
+                # Try to get value, continue on error
+                try:
+                    value = source.get_value(key)
+                    if value is not None:
+                        return value
+                except Exception:
+                    continue
+
+        return None
+
+
+def get_config_chain() -> list[RegistryEntry]:
+    """Get configuration sources ordered by priority."""
+    registry, registry_lock, ComponentCategory = _get_registry_and_lock()
+    
+    with registry_lock:
+        # Get all config sources
+        all_entries = list(registry)
+        config_sources = [
+            entry
+            for entry in all_entries
+            if entry.dimension == ComponentCategory.CONFIG_SOURCE.value
+        ]
+
+        # Sort by priority (highest first)
+        config_sources.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
+        return config_sources
+
+
+@with_error_handling(
+    fallback={},
+    context_provider=lambda: {"function": "load_all_configs"}
+)
+async def load_all_configs() -> dict[str, Any]:
+    """Load configurations from all registered sources."""
+    configs = {}
+    chain = get_config_chain()
+
+    for entry in chain:
+        source = entry.value
+        if hasattr(source, "load_config"):
+            try:
+                if inspect.iscoroutinefunction(source.load_config):
+                    source_config = await source.load_config()
+                else:
+                    source_config = source.load_config()
+
+                if source_config:
+                    configs.update(source_config)
+            except Exception as e:
+                log.warning(
+                    "Config source failed to load", source=entry.name, error=str(e)
+                )
+
+    return configs
+
+
+def load_config_from_registry(config_class: type[T]) -> T:
+    """
+    Load configuration from registry sources.
+    
+    Args:
+        config_class: Configuration class to instantiate
+        
+    Returns:
+        Configuration instance loaded from registry sources
+    """
+    registry, registry_lock, ComponentCategory = _get_registry_and_lock()
+    
+    with registry_lock:
+        # Get configuration data from registry
+        config_data = {}
+        
+        # Load from all config sources
+        chain = get_config_chain()
+        for entry in chain:
+            source = entry.value
+            if hasattr(source, "load_config"):
+                try:
+                    # Skip async sources in sync context
+                    if inspect.iscoroutinefunction(source.load_config):
+                        log.debug("Skipping async config source in sync context", source=entry.name)
+                        continue
+                    
+                    source_data = source.load_config()
+                    if source_data:
+                        config_data.update(source_data)
+                except Exception as e:
+                    log.warning(
+                        "Failed to load config from source", 
+                        source=entry.name, 
+                        error=str(e)
+                    )
+        
+        # Create config instance
+        return config_class.from_dict(config_data)
+
+
+__all__ = [
+    "resolve_config_value",
+    "get_config_chain", 
+    "load_all_configs",
+    "load_config_from_registry",
+]