Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
obj = {}
if isinstance(obj, str):
obj = yaml.load(obj, Loader=get_yaml_loader())
if obj is None:
return OmegaConf.create({})
elif isinstance(obj, str):
return OmegaConf.create({obj: None})
else:
assert isinstance(obj, (list, dict))
return OmegaConf.create(obj)
else:
if (
is_primitive_dict(obj)
or OmegaConf.is_dict(obj)
or is_structured_config(obj)
or obj is None
):
ref_type = None
if is_structured_config(obj):
ref_type = get_type_of(obj)
elif OmegaConf.is_dict(obj):
ref_type = obj._metadata.ref_type
if ref_type is None:
ref_type = OmegaConf.get_type(obj)
if isinstance(obj, DictConfig):
key_type = obj._metadata.key_type
element_type = obj._metadata.element_type
else:
key_type, element_type = get_dict_key_value_types(ref_type)
dest_node = dest._get_node(key, validate_access=False)
if isinstance(dest_node, Container) and OmegaConf.is_none(dest, key):
if not OmegaConf.is_none(src_value):
expand(dest_node)
if dest_node is not None:
if dest_node._is_interpolation():
target_node = dest_node._dereference_node(
throw_on_resolution_failure=False
)
if isinstance(target_node, Container):
dest[key] = target_node
dest_node = dest._get_node(key)
if is_structured_config(dest._metadata.element_type):
dest[key] = DictConfig(content=dest._metadata.element_type, parent=dest)
dest_node = dest._get_node(key)
if dest_node is not None:
if isinstance(dest_node, BaseContainer):
if isinstance(src_value, BaseContainer):
dest._validate_merge(key=key, value=src_value)
dest_node._merge_with(src_value)
else:
dest.__setitem__(key, src_value)
else:
if isinstance(src_value, BaseContainer):
dest.__setitem__(key, src_value)
else:
assert isinstance(dest_node, ValueNode)
try:
dest_node._merge_with(src_value)
else:
dest.__setitem__(key, src_value)
else:
if isinstance(src_value, BaseContainer):
dest.__setitem__(key, src_value)
else:
assert isinstance(dest_node, ValueNode)
try:
dest_node._set_value(src_value)
except (ValidationError, ReadonlyConfigError) as e:
dest._format_and_raise(key=key, value=src_value, cause=e)
else:
from omegaconf import open_dict
if is_structured_config(src_type):
# verified to be compatible above in _validate_set_merge_impl
with open_dict(dest):
dest[key] = src._get_node(key)
else:
dest[key] = src._get_node(key)
if src_type is not None and not is_primitive_dict(src_type):
dest._metadata.object_type = src_type
# explicit flags on the source config are replacing the flag values in the destination
for flag, value in src._metadata.flags.items():
if value is not None:
dest._set_flag(flag, value)
def _get_obj_type(c: Any) -> Optional[Type[Any]]:
if is_structured_config(c):
return get_type_of(c)
elif c is None:
return None
elif isinstance(c, DictConfig):
if c._is_none():
return None
elif c._is_missing():
return None
else:
if is_structured_config(c._metadata.object_type):
return c._metadata.object_type
else:
return dict
elif isinstance(c, ListConfig):
return list
elif isinstance(c, ValueNode):
return type(c._value())
elif isinstance(c, dict):
return dict
elif isinstance(c, (list, tuple)):
return list
else:
return get_type_of(c)
parent=parent,
ref_type=type_,
is_optional=is_optional,
key_type=key_type,
element_type=element_type,
)
elif is_list:
element_type = get_list_element_type(type_)
node = ListConfig(
content=value,
key=key,
parent=parent,
is_optional=is_optional,
element_type=element_type,
)
elif is_structured_config(type_) or is_structured_config(value):
key_type, element_type = get_dict_key_value_types(type_)
node = DictConfig(
ref_type=type_,
is_optional=is_optional,
content=value,
key=key,
parent=parent,
key_type=key_type,
element_type=element_type,
)
elif type_ == Any or type_ is None:
node = AnyNode(value=value, key=key, parent=parent, is_optional=is_optional)
elif issubclass(type_, Enum):
node = EnumNode(
enum_type=type_,
value=value,
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 _get_obj_type(c: Any) -> Optional[Type[Any]]:
if is_structured_config(c):
return get_type_of(c)
elif c is None:
return None
elif isinstance(c, DictConfig):
if c._is_none():
return None
elif c._is_missing():
return None
else:
if is_structured_config(c._metadata.object_type):
return c._metadata.object_type
else:
return dict
elif isinstance(c, ListConfig):
return list
elif isinstance(c, ValueNode):
assert not isinstance(value, ValueNode)
self._validate_set(key=None, value=value)
if OmegaConf.is_none(value):
self.__dict__["_content"] = None
self._metadata.object_type = None
elif _is_interpolation(value):
self.__dict__["_content"] = value
self._metadata.object_type = None
elif value == "???":
self.__dict__["_content"] = "???"
self._metadata.object_type = None
else:
self.__dict__["_content"] = {}
if is_structured_config(value):
self._metadata.object_type = None
data = get_structured_config_data(value)
for k, v in data.items():
self.__setitem__(k, v)
self._metadata.object_type = get_type_of(value)
elif isinstance(value, DictConfig):
self._metadata.object_type = dict
for k, v in value.__dict__["_content"].items():
self.__setitem__(k, v)
self.__dict__["_metadata"] = copy.deepcopy(value._metadata)
elif isinstance(value, dict):
for k, v in value.items():
self.__setitem__(k, v)
else:
assert False, f"Unsupported value type : {value}" # pragma: no cover