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,
)
