registry

ipw.core.registry

RegistryBase

Bases: Generic[T]

Registry helper

Source code in intelligence-per-watt/src/ipw/core/registry.py

class RegistryBase(Generic[T]):
    """Registry helper"""

    @classmethod
    def _entries(cls) -> Dict[str, T]:
        # Use class-specific attribute name to ensure isolation between registry types
        attr_name = f"_registry_entries_{cls.__name__}"
        storage = getattr(cls, attr_name, None)
        if storage is None:
            storage = {}
            setattr(cls, attr_name, storage)
        return storage

    @classmethod
    def register(cls, key: str) -> Callable[[T], T]:
        def decorator(entry: T) -> T:
            entries = cls._entries()
            if key in entries:
                raise ValueError(f"{cls.__name__} already has an entry for '{key}'")
            entries[key] = entry
            return entry

        return decorator

    @classmethod
    def register_value(cls, key: str, value: T) -> T:
        entries = cls._entries()
        if key in entries:
            raise ValueError(f"{cls.__name__} already has an entry for '{key}'")
        entries[key] = value
        return value

    @classmethod
    def get(cls, key: str) -> T:
        try:
            return cls._entries()[key]
        except KeyError as exc:
            raise KeyError(
                f"{cls.__name__} does not have an entry for '{key}'"
            ) from exc

    @classmethod
    def has(cls, key: str) -> bool:
        """Return True when the registry contains the key."""
        return key in cls._entries()

    @classmethod
    def create(cls, key: str, *args: Any, **kwargs: Any) -> Any:
        entry = cls.get(key)
        if not callable(entry):
            raise TypeError(
                f"{cls.__name__} entry '{key}' is not callable and cannot be instantiated"
            )
        return entry(*args, **kwargs)

    @classmethod
    def items(cls):
        return tuple(cls._entries().items())

    @classmethod
    def clear(cls) -> None:
        cls._entries().clear()

has(key) classmethod

Return True when the registry contains the key.

Source code in intelligence-per-watt/src/ipw/core/registry.py

@classmethod
def has(cls, key: str) -> bool:
    """Return True when the registry contains the key."""
    return key in cls._entries()

ClientRegistry

Bases: RegistryBase[Type['InferenceClient']]

Registry for inference clients.

Source code in intelligence-per-watt/src/ipw/core/registry.py

class ClientRegistry(RegistryBase[Type["InferenceClient"]]):
    """Registry for inference clients."""

DatasetRegistry

Bases: RegistryBase[Type['DatasetProvider']]

Registry for dataset providers.

Source code in intelligence-per-watt/src/ipw/core/registry.py

class DatasetRegistry(RegistryBase[Type["DatasetProvider"]]):
    """Registry for dataset providers."""

AnalysisRegistry

Bases: RegistryBase[Type['AnalysisProvider']]

Registry for analysis providers.

Source code in intelligence-per-watt/src/ipw/core/registry.py

class AnalysisRegistry(RegistryBase[Type["AnalysisProvider"]]):
    """Registry for analysis providers."""

VisualizationRegistry

Bases: RegistryBase[Type['VisualizationProvider']]

Registry for visualization providers.

Source code in intelligence-per-watt/src/ipw/core/registry.py

class VisualizationRegistry(RegistryBase[Type["VisualizationProvider"]]):
    """Registry for visualization providers."""

EvaluationRegistry

Bases: RegistryBase[Type['EvaluationHandler']]

Registry for evaluation handlers.

Source code in intelligence-per-watt/src/ipw/core/registry.py

class EvaluationRegistry(RegistryBase[Type["EvaluationHandler"]]):
    """Registry for evaluation handlers."""

AgentRegistry

Bases: RegistryBase[Type['BaseAgent']]

Registry for agent harnesses.

Source code in intelligence-per-watt/src/ipw/core/registry.py

class AgentRegistry(RegistryBase[Type["BaseAgent"]]):
    """Registry for agent harnesses."""