def test_maybe_wrap(target_type: type, value: Any, expectation: Any) -> None: with expectation: from omegaconf.omegaconf import _maybe_wrap _maybe_wrap(annotated_type=target_type, value=value, is_optional=False, parent=None)
def get_attr_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, Any]: from omegaconf.omegaconf import OmegaConf, _maybe_wrap flags = {"allow_objects": allow_objects} if allow_objects is not None else {} dummy_parent = OmegaConf.create(flags=flags) from omegaconf import MISSING d = {} is_type = isinstance(obj, type) obj_type = obj if is_type else type(obj) for name, attrib in attr.fields_dict(obj_type).items(): is_optional, type_ = _resolve_optional(attrib.type) type_ = _resolve_forward(type_, obj.__module__) if not is_type: value = getattr(obj, name) else: value = attrib.default if value == attr.NOTHING: value = MISSING if _is_union(type_): e = ConfigValueError( f"Union types are not supported:\n{name}: {type_str(type_)}" ) format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e)) d[name] = _maybe_wrap( ref_type=type_, is_optional=is_optional, key=name, value=value, parent=dummy_parent, ) d[name]._set_parent(None) return d
def get_dataclass_data(obj: Any) -> Dict[str, Any]: from omegaconf.omegaconf import _maybe_wrap d = {} for field in dataclasses.fields(obj): name = field.name is_optional, type_ = _resolve_optional(field.type) type_ = _resolve_forward(type_, obj.__module__) is_nested = is_structured_config(type_) if hasattr(obj, name): value = getattr(obj, name) else: if field.default_factory != dataclasses.MISSING: # type: ignore value = field.default_factory() # type: ignore else: if is_nested: value = type_ else: raise ValueError( "Missing default value for {}, to indicate " "default must be populated later use '???'".format( name)) d[name] = _maybe_wrap( annotated_type=type_, is_optional=is_optional, key=name, value=value, parent=None, ) return d
def get_attr_data(obj: Any) -> Dict[str, Any]: from omegaconf.omegaconf import _maybe_wrap d = {} is_type = isinstance(obj, type) obj_type = obj if is_type else type(obj) for name, attrib in attr.fields_dict(obj_type).items(): is_optional, type_ = _resolve_optional(attrib.type) type_ = _resolve_forward(type_, obj.__module__) is_nested = is_attr_class(type_) if not is_type: value = getattr(obj, name) else: value = attrib.default if value == attr.NOTHING: if is_nested: value = type_ else: raise ValueError( "Missing default value for {}, to indicate " "default must be populated later use '???'".format( name)) d[name] = _maybe_wrap( annotated_type=type_, is_optional=is_optional, key=name, value=value, parent=None, ) return d
def get_dataclass_data(obj: Any) -> Dict[str, Any]: from omegaconf.omegaconf import _maybe_wrap d = {} for field in dataclasses.fields(obj): name = field.name is_optional, type_ = _resolve_optional(field.type) type_ = _resolve_forward(type_, obj.__module__) is_nested = is_structured_config(type_) if hasattr(obj, name): value = getattr(obj, name) if value == dataclasses.MISSING: _raise_missing_error(obj, name) assert False else: if field.default_factory == dataclasses.MISSING: # type: ignore if is_nested: value = type_ else: _raise_missing_error(obj, name) assert False else: value = field.default_factory() # type: ignore if _is_union(type_): e = ConfigValueError( f"Union types are not supported:\n{name}: {type_str(type_)}" ) format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e)) d[name] = _maybe_wrap( ref_type=type_, is_optional=is_optional, key=name, value=value, parent=None, ) return d
def get_attr_data(obj: Any) -> Dict[str, Any]: from omegaconf.omegaconf import _maybe_wrap d = {} is_type = isinstance(obj, type) obj_type = obj if is_type else type(obj) for name, attrib in attr.fields_dict(obj_type).items(): is_optional, type_ = _resolve_optional(attrib.type) is_nested = is_attr_class(type_) type_ = _resolve_forward(type_, obj.__module__) if not is_type: value = getattr(obj, name) else: value = attrib.default if value == attr.NOTHING: if is_nested: value = type_ else: _raise_missing_error(obj, name) assert False if _is_union(type_): e = ConfigValueError( f"Union types are not supported:\n{name}: {type_str(type_)}" ) format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e)) d[name] = _maybe_wrap( ref_type=type_, is_optional=is_optional, key=name, value=value, parent=None, ) return d
def wrap(val: Any) -> Node: return _maybe_wrap( annotated_type=self.__dict__["_element_type"], value=val, is_optional=True, parent=self, )
def get_dataclass_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, Any]: from omegaconf.omegaconf import MISSING, OmegaConf, _maybe_wrap flags = { "allow_objects": allow_objects } if allow_objects is not None else {} d = {} is_type = isinstance(obj, type) obj_type = get_type_of(obj) dummy_parent = OmegaConf.create({}, flags=flags) dummy_parent._metadata.object_type = obj_type resolved_hints = get_type_hints(obj_type) for field in dataclasses.fields(obj): name = field.name is_optional, type_ = _resolve_optional(resolved_hints[field.name]) type_ = _resolve_forward(type_, obj.__module__) has_default = field.default != dataclasses.MISSING has_default_factory = field.default_factory != dataclasses.MISSING # type: ignore if not is_type: value = getattr(obj, name) else: if has_default: value = field.default elif has_default_factory: value = field.default_factory() # type: ignore else: value = MISSING if is_union_annotation( type_) and not is_supported_union_annotation(type_): e = ConfigValueError( f"Unions of containers are not supported:\n{name}: {type_str(type_)}" ) format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e)) try: d[name] = _maybe_wrap( ref_type=type_, is_optional=is_optional, key=name, value=value, parent=dummy_parent, ) except (ValidationError, GrammarParseError) as ex: format_and_raise(node=dummy_parent, key=name, value=value, cause=ex, msg=str(ex)) d[name]._set_parent(None) dict_subclass_data = extract_dict_subclass_data(obj=obj, parent=dummy_parent) if dict_subclass_data is not None: d.update(dict_subclass_data) return d
def insert(self, index: int, item: Any) -> None: from omegaconf.omegaconf import OmegaConf, _maybe_wrap try: if self._get_flag("readonly"): raise ReadonlyConfigError("Cannot insert into a read-only ListConfig") if self._is_none(): raise TypeError( "Cannot insert into ListConfig object representing None" ) if self._is_missing(): raise MissingMandatoryValue("Cannot insert into missing ListConfig") try: assert isinstance(self.__dict__["_content"], list) # insert place holder self.__dict__["_content"].insert(index, None) node = _maybe_wrap( ref_type=self.__dict__["_metadata"].element_type, key=index, value=item, is_optional=OmegaConf.is_optional(item), parent=self, ) self._validate_set(key=index, value=node) self._set_at_index(index, node) self._update_keys() except Exception: del self.__dict__["_content"][index] self._update_keys() raise except Exception as e: self._format_and_raise(key=index, value=item, cause=e) assert False
def test_node_wrap(target_type: Any, value: Any, expected: Any) -> None: from omegaconf.omegaconf import _maybe_wrap if isinstance(expected, Node): res = _node_wrap( type_=target_type, key="foo", value=value, is_optional=False, parent=None ) assert type(res) == type(expected) assert res == expected assert res._key() == "foo" else: with raises(expected): _maybe_wrap( ref_type=target_type, key=None, value=value, is_optional=False, parent=None, )
def wrap(key: Any, val: Any) -> Node: if is_structured_config(val): type_ = OmegaConf.get_type(val) else: type_ = self._metadata.element_type return _maybe_wrap( annotated_type=type_, key=key, value=val, is_optional=True, parent=self, )
def _wrap_value_and_set(self, key: Any, val: Any, type_hint: Any) -> None: from omegaconf.omegaconf import _maybe_wrap is_optional, ref_type = _resolve_optional(type_hint) wrapped = _maybe_wrap( ref_type=ref_type, key=key, value=val, is_optional=is_optional, parent=self, ) self.__dict__["_content"][key] = wrapped
def get_dataclass_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, Any]: from omegaconf.omegaconf import MISSING, OmegaConf, _maybe_wrap flags = { "allow_objects": allow_objects } if allow_objects is not None else {} dummy_parent = OmegaConf.create({}, flags=flags) d = {} resolved_hints = get_type_hints(get_type_of(obj)) for field in dataclasses.fields(obj): name = field.name is_optional, type_ = _resolve_optional(resolved_hints[field.name]) type_ = _resolve_forward(type_, obj.__module__) if hasattr(obj, name): value = getattr(obj, name) if value == dataclasses.MISSING: value = MISSING else: if field.default_factory == dataclasses.MISSING: # type: ignore value = MISSING else: value = field.default_factory() # type: ignore if _is_union(type_): e = ConfigValueError( f"Union types are not supported:\n{name}: {type_str(type_)}") format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e)) try: d[name] = _maybe_wrap( ref_type=type_, is_optional=is_optional, key=name, value=value, parent=dummy_parent, ) except ValidationError as ex: format_and_raise(node=None, key=name, value=value, cause=ex, msg=str(ex)) d[name]._set_parent(None) return d
def _wrap_value_and_set(self, key: Any, val: Any, type_hint: Any) -> None: from omegaconf.omegaconf import _maybe_wrap is_optional, ref_type = _resolve_optional(type_hint) try: wrapped = _maybe_wrap( ref_type=ref_type, key=key, value=val, is_optional=is_optional, parent=self, ) except ValidationError as e: self._format_and_raise(key=key, value=val, cause=e) self.__dict__["_content"][key] = wrapped
def append(self, item: Any) -> None: try: from omegaconf.omegaconf import OmegaConf, _maybe_wrap index = len(self) self._validate_set(key=index, value=item) node = _maybe_wrap( ref_type=self.__dict__["_metadata"].element_type, key=index, value=item, is_optional=OmegaConf.is_optional(item), parent=self, ) self.__dict__["_content"].append(node) except Exception as e: self._format_and_raise(key=index, value=item, cause=e) assert False
def extract_dict_subclass_data(obj: Any, parent: Any) -> Optional[Dict[str, Any]]: """Check if obj is an instance of a subclass of Dict. If so, extract the Dict keys/values.""" from omegaconf.omegaconf import _maybe_wrap is_type = isinstance(obj, type) obj_type = obj if is_type else type(obj) subclasses_dict = is_dict_subclass(obj_type) if subclasses_dict: warnings.warn( f"Class `{obj_type.__name__}` subclasses `Dict`." + " Subclassing `Dict` in Structured Config classes is deprecated," + " see github.com/omry/omegaconf/issues/663", UserWarning, stacklevel=9, ) if is_type: return None elif subclasses_dict: dict_subclass_data = {} key_type, element_type = get_dict_key_value_types(obj_type) for name, value in obj.items(): is_optional, type_ = _resolve_optional(element_type) type_ = _resolve_forward(type_, obj.__module__) try: dict_subclass_data[name] = _maybe_wrap( ref_type=type_, is_optional=is_optional, key=name, value=value, parent=parent, ) except ValidationError as ex: format_and_raise(node=None, key=name, value=value, cause=ex, msg=str(ex)) return dict_subclass_data else: return None
def wrap(key: Any, val: Any) -> Node: is_optional = True if not is_structured_config(val): ref_type = self._metadata.element_type else: target = self._get_node(key) if target is None: if is_structured_config(val): ref_type = OmegaConf.get_type(val) else: is_optional = target._is_optional() ref_type = target._metadata.ref_type return _maybe_wrap( ref_type=ref_type, key=key, value=val, is_optional=is_optional, parent=self, )
def append(self, item: Any) -> None: if self._get_flag("readonly"): raise ReadonlyConfigError(self.get_full_key(f"{len(self)}")) try: from omegaconf.omegaconf import _maybe_wrap self.__dict__["content"].append( _maybe_wrap( annotated_type=self.__dict__["_element_type"], value=item, is_optional=True, parent=self, )) except UnsupportedValueType: full_key = self.get_full_key(f"{len(self)}") raise UnsupportedValueType( f"key {full_key}: {type(item).__name__} is not a supported type" )
def append(self, item: Any) -> None: index = len(self) self._validate_set(key=index, value=item) try: from omegaconf.omegaconf import OmegaConf, _maybe_wrap self.__dict__["_content"].append( _maybe_wrap( annotated_type=self._metadata.element_type, key=index, value=item, is_optional=OmegaConf.is_optional(item), parent=self, )) except UnsupportedValueType: full_key = self._get_full_key(f"{len(self)}") raise UnsupportedValueType( f"{type(item).__name__} is not a supported type (key: {full_key})" )
def wrap(key: Any, val: Any) -> Node: if not is_structured_config(val): is_optional, ref_type = _resolve_optional( self._metadata.element_type) else: target = self._get_node(key) if target is None: is_optional, ref_type = _resolve_optional( self._metadata.element_type) else: assert isinstance(target, Node) is_optional = target._is_optional() ref_type = target._metadata.ref_type return _maybe_wrap( ref_type=ref_type, key=key, value=val, is_optional=is_optional, parent=self, )