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)