Registry

hya.registry

Implement the resolver registry to easily register resolvers.

hya.registry.ResolverRegistry

Implement a resolver registry.

This class manages a collection of resolver functions that can be registered with keys and later used with OmegaConf.

Parameters:

Name	Type	Description	Default
state	dict[str, Callable[..., Any]] | None	Optional initial state dictionary containing key-resolver pairs. If provided, a copy is made to prevent external modifications.	None

Example

>>> from hya.registry import ResolverRegistry
>>> registry = ResolverRegistry()
>>> @registry.register("my_key")
... def my_resolver(value):
...     pass
...

hya.registry.ResolverRegistry.state property

state: dict[str, Callable[..., Any]]

The state of the registry.

hya.registry.ResolverRegistry.has_resolver

has_resolver(key: str) -> bool

Check if a resolver is explicitly registered for the given key.

Parameters:

Name	Type	Description	Default
key	str	The key to check.	required

Returns:

Type	Description
bool	True if a resolver is registered for this key,
bool	False otherwise

Example

>>> from hya.registry import ResolverRegistry
>>> registry = ResolverRegistry()
>>> @registry.register("my_key")
... def my_resolver(value):
...     pass
...
>>> registry.has_resolver("my_key")
True
>>> registry.has_resolver("missing")
False

hya.registry.ResolverRegistry.register

register(
    key: str, exist_ok: bool = False
) -> Callable[[F], F]

Register a resolver to registry with the specified key.

This method returns a decorator that can be used to register resolver functions.

Parameters:

Name	Type	Description	Default
key	str	The key used to register the resolver. Must be unique unless exist_ok is True.	required
exist_ok	bool	If False, a RuntimeError is raised if you try to register a new resolver with an existing key. If True, the existing resolver will be overridden.	False

Returns:

Type	Description
Callable[[F], F]	A decorator function that registers the resolver and returns it unchanged.

Raises:

Type	Description
TypeError	If the resolver is not callable.
RuntimeError	If the key already exists and exist_ok is False.

Example

>>> from hya.registry import ResolverRegistry
>>> registry = ResolverRegistry()
>>> @registry.register("my_key")
... def my_resolver(value):
...     return value * 2
...
>>> my_resolver(5)
10

hya.registry.ResolverRegistry.register_resolvers

register_resolvers() -> None

Register the resolvers to OmegaConf.

This method iterates through all registered resolvers and registers them with OmegaConf if they haven't been registered already.

Example

>>> from hya.registry import ResolverRegistry
>>> registry = ResolverRegistry()
>>> @registry.register("multiply")
... def multiply_resolver(x, y):
...     return x * y
...
>>> registry.register_resolvers()

hya.registry.get_default_registry

get_default_registry() -> ResolverRegistry

Get or create the default global resolver registry.

Returns a singleton registry instance using a simple singleton pattern. The registry is initially empty and can be populated with custom resolvers.

This function uses a singleton pattern to ensure the same registry instance is returned on subsequent calls, which is efficient and maintains consistency across an application.

Returns:

Type	Description
ResolverRegistry	A ResolverRegistry instance

Notes

The singleton pattern means modifications to the returned registry affect all future calls to this function. If you need an isolated registry, create a new ResolverRegistry instance directly.

Example

>>> from hya.registry import get_default_registry
>>> registry = get_default_registry()
>>> @registry.register("my_key")
... def my_resolver(value):
...     pass
...