def get_method(path: str) -> Callable[..., Any]:
try:
cl = _locate(path)
if not callable(cl):
raise ValueError(f"Non callable object located : {type(cl).__name__}")
return cl
except Exception as e:
log.error(f"Error getting callable at {path} : {e}")
raise e
def get_class(path: str) -> type:
try:
cls = _locate(path)
if not isinstance(cls, type):
raise ValueError(f"Located non-class in {path} : {type(cls).__name__}")
return cls
except Exception as e:
log.error(f"Error initializing class at {path} : {e}")
raise e
def _resolve_target(
target: Union[str, type, Callable[..., Any]]
) -> Union[type, Callable[..., Any]]:
"""Resolve target string, type or callable into type or callable."""
if isinstance(target, str):
return _locate(target)
if isinstance(target, type):
return target
if callable(target):
return target
raise InstantiationException(
f"Unsupported target type: {type(target).__name__}. value: {target}")
def get_method(path: str) -> Callable[..., Any]:
try:
obj = _locate(path)
if not callable(obj):
raise ValueError(
f"Located non-callable of type '{type(obj).__name__}'" +
f" while loading '{path}'")
cl: Callable[..., Any] = obj
return cl
except Exception as e:
log.error(f"Error getting callable at {path} : {e}")
raise e
def call(config: Any, *args: Any, **kwargs: Any) -> Any:
"""
:param config: An object describing what to call and what params to use.
Must have a _target_ field.
:param args: optional positional parameters pass-through
:param kwargs: optional named parameters pass-through
:return: the return value from the specified class or method
"""
if OmegaConf.is_none(config):
return None
if isinstance(config, TargetConf) and config._target_ == "???":
# Specific check to give a good warning about failure to annotate _target_ as a string.
raise InstantiationException(
f"Missing value for {type(config).__name__}._target_. Check that it's properly annotated and overridden."
f"\nA common problem is forgetting to annotate _target_ as a string : '_target_: str = ...'"
)
if not (isinstance(config, dict) or OmegaConf.is_config(config)
or is_structured_config(config)):
raise HydraException(
f"Unsupported config type : {type(config).__name__}")
# make a copy to ensure we do not change the provided object
config_copy = OmegaConf.structured(config)
if OmegaConf.is_config(config):
config_copy._set_parent(config._get_parent())
config = config_copy
cls = "<unknown>"
try:
assert isinstance(config, DictConfig)
OmegaConf.set_readonly(config, False)
OmegaConf.set_struct(config, False)
cls = _get_cls_name(config)
type_or_callable = _locate(cls)
if isinstance(type_or_callable, type):
return _instantiate_class(type_or_callable, config, *args,
**kwargs)
else:
assert callable(type_or_callable)
return _call_callable(type_or_callable, config, *args, **kwargs)
except InstantiationException as e:
raise e
except Exception as e:
raise HydraException(f"Error calling '{cls}' : {e}") from e
def _resolve_target(target: Union[str, type, Callable[..., Any]],
full_key: str) -> Union[type, Callable[..., Any]]:
"""Resolve target string, type or callable into type or callable."""
if isinstance(target, str):
try:
target = _locate(target)
except Exception as e:
msg = f"Error locating target '{target}', see chained exception above."
if full_key:
msg += f"\nfull_key: {full_key}"
raise InstantiationException(msg) from e
if not callable(target):
msg = f"Expected a callable target, got '{target}' of type '{type(target).__name__}'"
if full_key:
msg += f"\nfull_key: {full_key}"
raise InstantiationException(msg)
return target
def call(config: Union[ObjectConf, DictConfig], *args: Any, **kwargs: Any) -> Any:
"""
:param config: An ObjectConf or DictConfig describing what to call and what params to use
:param args: optional positional parameters pass-through
:param kwargs: optional named parameters pass-through
:return: the return value from the specified class or method
"""
if OmegaConf.is_none(config):
return None
try:
cls = _get_cls_name(config)
type_or_callable = _locate(cls)
if isinstance(type_or_callable, type):
return _instantiate_class(type_or_callable, config, *args, **kwargs)
else:
assert callable(type_or_callable)
return _call_callable(type_or_callable, config, *args, **kwargs)
except Exception as e:
raise HydraException(f"Error calling '{cls}' : {e}") from e
def call(
config: Union[ObjectConf, TargetConf, DictConfig, Dict[Any, Any]],
*args: Any,
**kwargs: Any,
) -> Any:
"""
:param config: An object describing what to call and what params to use
:param args: optional positional parameters pass-through
:param kwargs: optional named parameters pass-through
:return: the return value from the specified class or method
"""
if isinstance(config, TargetConf) and config._target_ == "???":
raise InstantiationException(
f"Missing _target_ value. Check that you specified it in '{type(config).__name__}'"
f" and that the type annotation is correct: '_target_: str = ...'")
if isinstance(config, (dict, ObjectConf, TargetConf)):
config = OmegaConf.structured(config)
if OmegaConf.is_none(config):
return None
cls = "<unknown>"
try:
assert isinstance(config, DictConfig)
# make a copy to ensure we do not change the provided object
config = copy.deepcopy(config)
OmegaConf.set_readonly(config, False)
OmegaConf.set_struct(config, False)
cls = _get_cls_name(config)
type_or_callable = _locate(cls)
if isinstance(type_or_callable, type):
return _instantiate_class(type_or_callable, config, *args,
**kwargs)
else:
assert callable(type_or_callable)
return _call_callable(type_or_callable, config, *args, **kwargs)
except InstantiationException as e:
raise e
except Exception as e:
raise HydraException(f"Error calling '{cls}' : {e}") from e
def test_locate(name: str, expected: Any) -> None:
if isinstance(expected, RaisesContext):
with expected:
_locate(name)
else:
assert _locate(name) == expected
def get_partial(*args, **kwargs):
func_or_obj = _locate(kwargs.pop("_partial_"))
return partial(func_or_obj, *args, **kwargs)
