Discovery

provide.foundation.hub.discovery

TODO: Add module docstring.

Classes

Functions

discover_components

discover_components(
    group: str,
    dimension: str | None = None,
    registry: Registry | None = None,
) -> dict[str, type[Any]]

Discover and register components from entry points.

Uses the @resilient decorator for standardized error handling.

Parameters:

Name	Type	Description	Default
group	str	Entry point group name (e.g., 'provide.components')	required
dimension	str | None	Registry dimension for components (defaults to "component")	None
registry	Registry | None	Optional registry to use (defaults to global registry)	None

Returns:

Type	Description
dict[str, type[Any]]	Dictionary mapping component names to their classes

Source code in provide/foundation/hub/discovery.py

def discover_components(
    group: str,
    dimension: str | None = None,
    registry: Registry | None = None,
) -> dict[str, type[Any]]:
    """Discover and register components from entry points.

    Uses the @resilient decorator for standardized error handling.

    Args:
        group: Entry point group name (e.g., 'provide.components')
        dimension: Registry dimension for components (defaults to "component")
        registry: Optional registry to use (defaults to global registry)

    Returns:
        Dictionary mapping component names to their classes

    """
    # Use ComponentCategory default if not specified
    if dimension is None:
        dimension = ComponentCategory.COMPONENT.value

    discovered = {}

    # If no registry provided, get the global component registry
    if registry is None:
        registry = _get_registry_and_lock()

    # Get entry points for the group (with resilient error handling)
    group_entries = _get_entry_points(group)

    # Load each entry point (with resilient error handling per entry point)
    for entry_point in group_entries:
        result = _load_entry_point(entry_point, registry, dimension)
        if result is not None:
            name, component_class = result
            discovered[name] = component_class

    return discovered

resolve_component_dependencies

resolve_component_dependencies(
    name: str, dimension: str
) -> dict[str, Any]

Resolve component dependencies recursively.

Source code in provide/foundation/hub/discovery.py

def resolve_component_dependencies(name: str, dimension: str) -> dict[str, Any]:
    """Resolve component dependencies recursively."""
    registry = _get_registry_and_lock()

    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