omegaconf 2.4.0.dev13__tar.gz → 2.4.0.dev14__tar.gz

{omegaconf-2.4.0.dev13/omegaconf.egg-info → omegaconf-2.4.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omegaconf
-Version: 2.4.0.dev13
+Version: 2.4.0.dev14
 Summary: A flexible configuration library
 Home-page: https://github.com/omry/omegaconf
 Author: Omry Yadan
@@ -22,19 +22,16 @@ Requires-Dist: PyYAML>=5.1.0; extra == "dev"
 Requires-Dist: sphinx; extra == "dev"
 Requires-Dist: sphinx-tabs; extra == "dev"
 Requires-Dist: attrs; extra == "dev"
-Requires-Dist: black[jupyter]==26.3.1; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: bump-my-version; extra == "dev"
 Requires-Dist: coveralls; extra == "dev"
-Requires-Dist: flake8==7.3.0; extra == "dev"
-Requires-Dist: isort==5.13.2; extra == "dev"
 Requires-Dist: nox[pbs]; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: pyflakes; extra == "dev"
 Requires-Dist: pyrefly==0.62.0; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-benchmark; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: ruff==0.15.22; extra == "dev"
 Requires-Dist: towncrier; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: pydevd; extra == "dev"

omegaconf-2.4.0.dev14/build_helpers/__init__.py

@@ -0,0 +1,5 @@
+# ruff: noqa: F401, I001
+
+# Order of imports is important (see warning otherwise when running tests)
+import setuptools
+import distutils

{omegaconf-2.4.0.dev13 → omegaconf-2.4.0.dev14}/build_helpers/get_vendored.py

@@ -6,10 +6,12 @@ from itertools import chain
 from pathlib import Path
 from typing import Callable, FrozenSet, Generator, List, Set, Tuple, Union
 
-WHITELIST = {'README.txt', '__init__.py', 'vendor.txt'}
+WHITELIST = {"README.txt", "__init__.py", "vendor.txt"}
 
 
-def delete_all(*paths: Path, whitelist: Union[Set[str], FrozenSet[str]] = frozenset()) -> None:
+def delete_all(
+    *paths: Path, whitelist: Union[Set[str], FrozenSet[str]] = frozenset()
+) -> None:
     """Clear all the items in each of the indicated paths, except for elements listed
     in the whitelist"""
     for item in paths:
@@ -34,13 +36,15 @@ def iter_subtree(path: Path, depth: int = 0) -> Generator[Tuple[Path, int], None
 
 def patch_vendor_imports(file: Path, replacements: List[Callable[[str], str]]) -> None:
     """Apply a list of replacements/patches to a given file"""
-    text = file.read_text('utf8')
+    text = file.read_text("utf8")
     for replacement in replacements:
         text = replacement(text)
-    file.write_text(text, 'utf8')
+    file.write_text(text, "utf8")
 
 
-def find_vendored_libs(vendor_dir: Path, whitelist: Set[str]) -> Tuple[List[str], List[Path]]:
+def find_vendored_libs(
+    vendor_dir: Path, whitelist: Set[str]
+) -> Tuple[List[str], List[Path]]:
     vendored_libs = []
     paths = []
     for item in vendor_dir.iterdir():
@@ -56,23 +60,31 @@ def find_vendored_libs(vendor_dir: Path, whitelist: Set[str]) -> Tuple[List[str]
 
 def vendor(vendor_dir: Path, relative_imports: bool = False) -> None:
     # target package is <parent>.<vendor_dir>; foo/vendor -> foo.vendor
-    pkgname = f'{vendor_dir.parent.name}.{vendor_dir.name}'
+    pkgname = f"{vendor_dir.parent.name}.{vendor_dir.name}"
 
     # remove everything
     delete_all(*vendor_dir.iterdir(), whitelist=WHITELIST)
 
     # install with pip
-    subprocess.run([
-        'pip', 'install', '-t', str(vendor_dir),
-        '-r', str(vendor_dir / 'vendor.txt'),
-        '--no-compile', '--no-deps'
-    ])
+    subprocess.run(
+        [
+            "pip",
+            "install",
+            "-t",
+            str(vendor_dir),
+            "-r",
+            str(vendor_dir / "vendor.txt"),
+            "--no-compile",
+            "--no-deps",
+        ]
+    )
 
     # delete stuff that's not needed
     delete_all(
-        *vendor_dir.glob('*.dist-info'),
-        *vendor_dir.glob('*.egg-info'),
-        vendor_dir / 'bin')
+        *vendor_dir.glob("*.dist-info"),
+        *vendor_dir.glob("*.egg-info"),
+        vendor_dir / "bin",
+    )
 
     vendored_libs, paths = find_vendored_libs(vendor_dir, WHITELIST)
 
@@ -81,41 +93,45 @@ def vendor(vendor_dir: Path, relative_imports: bool = False) -> None:
         for lib in vendored_libs:
             replacements += (
                 partial(  # import bar -> import foo.vendor.bar
-                    re.compile(r'(^\s*)import {}\n'.format(lib), flags=re.M).sub,
-                    r'\1from {} import {}\n'.format(pkgname, lib)
+                    re.compile(r"(^\s*)import {}\n".format(lib), flags=re.M).sub,
+                    r"\1from {} import {}\n".format(pkgname, lib),
                 ),
                 partial(  # from bar -> from foo.vendor.bar
-                    re.compile(r'(^\s*)from {}(\.|\s+)'.format(lib), flags=re.M).sub,
-                    r'\1from {}.{}\2'.format(pkgname, lib)
+                    re.compile(r"(^\s*)from {}(\.|\s+)".format(lib), flags=re.M).sub,
+                    r"\1from {}.{}\2".format(pkgname, lib),
                 ),
             )
 
     for file, depth in chain.from_iterable(map(iter_subtree, paths)):
         if relative_imports:
-            pkgname = '.' * (depth - 1)
+            pkgname = "." * (depth - 1)
             replacements = []
             for lib in vendored_libs:
                 replacements += (
                     partial(
-                        re.compile(r'(^\s*)import {}\n'.format(lib), flags=re.M).sub,
-                        r'\1from {} import {}\n'.format(pkgname, "")
+                        re.compile(r"(^\s*)import {}\n".format(lib), flags=re.M).sub,
+                        r"\1from {} import {}\n".format(pkgname, ""),
                     ),
                     partial(
-                        re.compile(r'^from {}(\s+)'.format(lib), flags=re.M).sub,
-                        r'from .{}\1'.format(pkgname)
+                        re.compile(r"^from {}(\s+)".format(lib), flags=re.M).sub,
+                        r"from .{}\1".format(pkgname),
                     ),
                     partial(
-                        re.compile(r'(^\s*)from {}(\.+)'.format(lib), flags=re.M).sub,
-                        r'\1from {}\2'.format(pkgname)
+                        re.compile(r"(^\s*)from {}(\.+)".format(lib), flags=re.M).sub,
+                        r"\1from {}\2".format(pkgname),
                     ),
                 )
         patch_vendor_imports(file, replacements)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # this assumes this is a script in `build_helpers`
-    here = Path('__file__').resolve().parent
-    vendor_dir = here / 'omegaconf' / 'vendor'
-    assert (vendor_dir / 'vendor.txt').exists(), 'omegaconf/vendor/vendor.txt file not found'
-    assert (vendor_dir / '__init__.py').exists(), 'omegaconf/vendor/__init__.py file not found'
+    repo_root = Path(__file__).resolve().parent.parent
+    vendor_dir = repo_root / "omegaconf" / "vendor"
+    assert (vendor_dir / "vendor.txt").exists(), (
+        "omegaconf/vendor/vendor.txt file not found"
+    )
+    assert (vendor_dir / "__init__.py").exists(), (
+        "omegaconf/vendor/__init__.py file not found"
+    )
     vendor(vendor_dir, relative_imports=True)

{omegaconf-2.4.0.dev13 → omegaconf-2.4.0.dev14}/omegaconf/__init__.py

@@ -1,4 +1,4 @@
-from .base import Container, DictKeyType, ListMergeMode, Node, SCMode, UnionNode
+from .base import Container, DictKeyType, Node, SCMode, UnionNode
 from .dictconfig import DictConfig
 from .errors import (
     KeyValidationError,
@@ -50,7 +50,6 @@ __all__ = [
     "OmegaConf",
     "Resolver",
     "SCMode",
-    "ListMergeMode",
     "flag_override",
     "read_write",
     "open_dict",

{omegaconf-2.4.0.dev13 → omegaconf-2.4.0.dev14}/omegaconf/_utils.py

@@ -52,6 +52,8 @@ if TYPE_CHECKING:
     import attr
     from attr import Attribute as AttrAttribute
 
+    from .basecontainer import BaseContainer
+
 
 NoneType: Type[None] = type(None)
 
@@ -230,26 +232,130 @@ def is_union_annotation(type_: Any) -> bool:
     return getattr(type_, "__origin__", None) is Union
 
 
-def _resolve_optional(type_: Any) -> Tuple[bool, Any]:
-    """Check whether `type_` is equivalent to `typing.Optional[T]` for some T."""
+def _resolve_type_alias(type_: Any) -> Any:
     if sys.version_info >= (3, 12):  # pragma: no cover
         import typing  # lgtm [py/import-and-import-from]
 
-        if isinstance(type_, typing.TypeAliasType):
-            type_ = type_.__value__
+        seen = set()
+        while id(type_) not in seen:
+            seen.add(id(type_))
+            if isinstance(type_, typing.TypeAliasType):
+                bare_alias = True
+                origin = type_
+                arguments: Tuple[Any, ...] = ()
+            else:
+                bare_alias = False
+                origin = typing.get_origin(type_)
+                if not isinstance(origin, typing.TypeAliasType):
+                    break
+                arguments = typing.get_args(type_)
+
+            parameters = origin.__type_params__
+            variadic = [
+                parameter
+                for parameter in parameters
+                if isinstance(parameter, typing.TypeVarTuple)
+            ]
+            if len(variadic) > 1:
+                break
+
+            if bare_alias:
+                substitutions = {}
+            elif variadic:
+                variadic_index = parameters.index(variadic[0])
+                trailing = len(parameters) - variadic_index - 1
+                if len(arguments) < len(parameters) - 1:
+                    break
+                substitutions = dict(zip(parameters[:variadic_index], arguments))
+                substitutions[variadic[0]] = arguments[
+                    variadic_index : len(arguments) - trailing if trailing else None
+                ]
+                if trailing:
+                    substitutions.update(
+                        zip(parameters[-trailing:], arguments[-trailing:])
+                    )
+            else:
+                if len(arguments) > len(parameters):
+                    break
+                substitutions = dict(zip(parameters, arguments))
+
+            def substitution_args(value: Any) -> Tuple[Any, ...]:
+                result = []
+                for parameter in getattr(value, "__parameters__", ()):
+                    argument = substitutions[parameter]
+                    if isinstance(parameter, typing.TypeVarTuple):
+                        result.extend(argument)
+                    else:
+                        result.append(argument)
+                return tuple(result)
+
+            no_default = getattr(typing, "NoDefault", None)
+            for parameter in parameters:
+                if parameter in substitutions:
+                    continue
+                default: Any = getattr(parameter, "__default__", no_default)
+                if default is no_default:
+                    break
+
+                for known_parameter, argument in substitutions.items():
+                    if default is known_parameter:
+                        default = argument
+                        break
+                else:
+                    default_parameters = getattr(default, "__parameters__", ())
+                    if default_parameters:
+                        try:
+                            default_arguments = substitution_args(default)
+                        except KeyError:
+                            break
+                        default = default[default_arguments]
+                if isinstance(parameter, typing.TypeVarTuple):
+                    default_args = typing.get_args(default)
+                    if typing.get_origin(default) is typing.Unpack and default_args:
+                        default = typing.get_args(default_args[0])
+                substitutions[parameter] = default
+            else:
+                value = origin.__value__
+                for parameter, argument in substitutions.items():
+                    if value is parameter:
+                        value = argument
+                        break
+                else:
+                    value_parameters = getattr(value, "__parameters__", ())
+                    if value_parameters:
+                        try:
+                            value_arguments = substitution_args(value)
+                        except KeyError:
+                            break
+                        value = value[value_arguments]
+                type_ = value
+                continue
+            break
+    return type_
+
+
+def _resolve_optional(type_: Any) -> Tuple[bool, Any]:
+    """Normalize aliases and check whether `type_` accepts None."""
+    type_ = _resolve_type_alias(type_)
     if is_union_annotation(type_):
-        args = type_.__args__
-        if NoneType in args:
-            optional = True
-            args = tuple(a for a in args if a is not NoneType)
-        else:
-            optional = False
+        optional = False
+        args = []
+        for arg in type_.__args__:
+            arg_optional, arg_type = _resolve_optional(arg)
+            if arg_type is Any:
+                return True, Any
+            optional = optional or arg_optional
+            if arg_type is NoneType:
+                continue
+            args.append(arg_type)
+
         if len(args) == 1:
             return optional, args[0]
         elif len(args) >= 2:
-            return optional, Union[args]
+            return optional, Union[tuple(args)]  # pyrefly: ignore[not-a-type]
         else:
-            assert False
+            # Only distinct PEP 695 aliases that all resolve to None can reach this.
+            return True, NoneType  # pragma: no cover
 
     if type_ is Any:
         return True, Any
@@ -271,30 +377,111 @@ def _is_optional(obj: Any, key: Optional[Union[int, str]] = None) -> bool:
     return obj._is_optional()
 
 
-def _resolve_forward(type_: Type[Any], module: str) -> Type[Any]:
+def _resolve_forward(
+    type_: Type[Any],
+    module: str,
+    preserve_container_origin: bool = False,
+    type_alias_guard: Optional[set[int]] = None,
+) -> Type[Any]:
     import typing  # lgtm [py/import-and-import-from]
 
+    if sys.version_info >= (3, 12):  # pragma: no cover
+        type_alias = (
+            type_
+            if isinstance(type_, typing.TypeAliasType)
+            else typing.get_origin(type_)
+        )
+        if isinstance(type_alias, typing.TypeAliasType):
+            if type_alias_guard is None:
+                type_alias_guard = set()
+            if id(type_alias) in type_alias_guard:
+                raise ValidationError(
+                    f"Recursive type alias '{type_alias.__name__}' is not supported"
+                )
+            type_alias_guard = type_alias_guard | {id(type_alias)}
+
+    type_ = _resolve_type_alias(type_)
     forward = typing.ForwardRef if hasattr(typing, "ForwardRef") else typing._ForwardRef  # type: ignore
     if type(type_) is forward:
         return _get_class(module, type_.__forward_arg__)
     elif isinstance(type_, str):
         return _get_class(module, type_)
+    elif is_union_annotation(type_):
+        is_optional, type_ = _resolve_optional(type_)
+        if type_ is Any:
+            return Any
+        if is_union_annotation(type_):
+            args = tuple(
+                _resolve_forward(
+                    arg,
+                    module=module,
+                    preserve_container_origin=True,
+                    type_alias_guard=type_alias_guard,
+                )
+                for arg in type_.__args__
+            )
+            type_ = Union[args]  # pyrefly: ignore[not-a-type]
+        else:
+            type_ = _resolve_forward(
+                type_,
+                module=module,
+                preserve_container_origin=True,
+                type_alias_guard=type_alias_guard,
+            )
+        return Optional[type_] if is_optional else type_
     else:
         if is_dict_annotation(type_):
+            if preserve_container_origin and (
+                type_ in (dict, Dict) or getattr(type_, "__origin__", None) is None
+            ):
+                return type_
             kt, vt = get_dict_key_value_types(type_)
             if kt is not None:
-                kt = _resolve_forward(kt, module=module)
+                kt = _resolve_forward(
+                    kt,
+                    module=module,
+                    preserve_container_origin=preserve_container_origin,
+                    type_alias_guard=type_alias_guard,
+                )
             if vt is not None:
-                vt = _resolve_forward(vt, module=module)
+                vt = _resolve_forward(
+                    vt,
+                    module=module,
+                    preserve_container_origin=preserve_container_origin,
+                    type_alias_guard=type_alias_guard,
+                )
+            if preserve_container_origin and isinstance(type_, types.GenericAlias):
+                return dict[kt, vt]  # type: ignore
             return Dict[kt, vt]  # type: ignore
         if is_list_annotation(type_):
+            if preserve_container_origin and type_ in (list, List):
+                return type_
             et = get_list_element_type(type_)
             if et is not None:
-                et = _resolve_forward(et, module=module)
+                et = _resolve_forward(
+                    et,
+                    module=module,
+                    preserve_container_origin=preserve_container_origin,
+                    type_alias_guard=type_alias_guard,
+                )
+            if preserve_container_origin and isinstance(type_, types.GenericAlias):
+                return list[et]  # type: ignore
             return List[et]  # type: ignore
         if is_tuple_annotation(type_):
+            if preserve_container_origin and type_ in (tuple, Tuple):
+                return type_
             its = get_tuple_item_types(type_)
-            its = tuple(_resolve_forward(it, module=module) for it in its)
+            its = tuple(
+                _resolve_forward(
+                    it,
+                    module=module,
+                    preserve_container_origin=preserve_container_origin,
+                    type_alias_guard=type_alias_guard,
+                )
+                for it in its
+            )
+            if preserve_container_origin and isinstance(type_, types.GenericAlias):
+                return tuple[its]  # type: ignore
             return Tuple[its]  # type: ignore
 
         return type_
@@ -350,7 +537,11 @@ def get_attr_class_fields(obj: Any) -> List["AttrAttribute[Any]"]:
     return [f for f in fields if f.metadata.get("omegaconf_ignore") is not True]
 
 
-def get_attr_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, Any]:
+def get_attr_data(
+    obj: Any,
+    allow_objects: Optional[bool] = None,
+    parent: Optional["BaseContainer"] = None,
+) -> Dict[str, Any]:
     from omegaconf.base import Node
     from omegaconf.omegaconf import OmegaConf, _maybe_wrap
 
@@ -363,6 +554,9 @@ def get_attr_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, A
     obj_type = obj if is_type else type(obj)
     dummy_parent = OmegaConf.create({}, flags=flags)
     dummy_parent._metadata.object_type = obj_type
+    if parent is not None:
+        dummy_parent._set_key(parent._key())
+        dummy_parent._set_parent(parent._get_parent())
     resolved_hints = get_type_hints(obj_type)
 
     for attrib in get_attr_class_fields(obj):
@@ -393,7 +587,7 @@ def get_attr_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, A
             value = copy.deepcopy(value)
         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_)}"  # noqa: E231
+                f"Unsupported type annotation in Union:\n{name}: {type_str(type_)}"  # noqa: E231
             )
             format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e))
 
@@ -422,7 +616,9 @@ def get_dataclass_fields(obj: Any) -> List["dataclasses.Field[Any]"]:
 
 
 def get_dataclass_data(
-    obj: Any, allow_objects: Optional[bool] = None
+    obj: Any,
+    allow_objects: Optional[bool] = None,
+    parent: Optional["BaseContainer"] = None,
 ) -> Dict[str, Any]:
     from omegaconf.base import Node
     from omegaconf.omegaconf import MISSING, OmegaConf, _maybe_wrap
@@ -433,6 +629,9 @@ def get_dataclass_data(
     obj_type = get_type_of(obj)
     dummy_parent = OmegaConf.create({}, flags=flags)
     dummy_parent._metadata.object_type = obj_type
+    if parent is not None:
+        dummy_parent._set_key(parent._key())
+        dummy_parent._set_parent(parent._get_parent())
     resolved_hints = get_type_hints(obj_type)
     for field in get_dataclass_fields(obj):
         name = field.name
@@ -455,7 +654,7 @@ def get_dataclass_data(
 
         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_)}"  # noqa: E231
+                f"Unsupported type annotation in Union:\n{name}: {type_str(type_)}"  # noqa: E231
             )
             format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e))
         try:
@@ -552,12 +751,14 @@ def get_structured_config_init_field_aliases(obj: Any) -> Dict[str, str]:
 
 
 def get_structured_config_data(
-    obj: Any, allow_objects: Optional[bool] = None
+    obj: Any,
+    allow_objects: Optional[bool] = None,
+    parent: Optional["BaseContainer"] = None,
 ) -> Dict[str, Any]:
     if is_dataclass(obj):
-        return get_dataclass_data(obj, allow_objects=allow_objects)
+        return get_dataclass_data(obj, allow_objects=allow_objects, parent=parent)
     elif is_attr_class(obj):
-        return get_attr_data(obj, allow_objects=allow_objects)
+        return get_attr_data(obj, allow_objects=allow_objects, parent=parent)
     else:
         raise ValueError(f"Unsupported type: {type(obj).__name__}")
 
@@ -715,21 +916,58 @@ def is_tuple_annotation(type_: Any) -> bool:
 
 
 def is_supported_union_annotation(obj: Any) -> bool:
-    """Primitives and typed List/Dict containers are supported in Unions."""
+    """Supported value annotations can be used as members of Unions."""
+    obj = _resolve_type_alias(obj)
     if not is_union_annotation(obj):
         return False
-    args = obj.__args__
+    _, obj = _resolve_optional(obj)
+    if obj is Any:
+        return True
+    args = obj.__args__ if is_union_annotation(obj) else (obj,)
     return all(
-        is_primitive_type_annotation(arg) or is_container_annotation(arg)
+        is_primitive_type_annotation(arg)
+        or is_literal_annotation(arg)
+        or is_structured_config(arg)
+        or is_container_annotation(arg)
         for arg in args
     )
 
 
+def select_structured_config_union_member(
+    value: Any, candidates: List[Any]
+) -> Optional[Any]:
+    from omegaconf.dictconfig import DictConfig
+
+    if isinstance(value, DictConfig):
+        value_type = value._metadata.object_type
+    elif is_structured_config(value):
+        value_type = get_type_of(value)
+    else:
+        return None
+
+    if not is_structured_config(value_type):
+        return None
+
+    candidate_set = set(candidates)
+    return next(
+        (base for base in value_type.__mro__ if base in candidate_set),
+        None,
+    )
+
+
 def is_literal_annotation(type_: Any) -> bool:
     origin = getattr(type_, "__origin__", None)
     return origin is Literal
 
 
+def type_hint_contains_none_literal(type_: Any) -> bool:
+    if is_literal_annotation(type_):
+        return any(arg is None for arg in type_.__args__)
+    return is_union_annotation(type_) and any(
+        type_hint_contains_none_literal(arg) for arg in type_.__args__
+    )
+
+
 def is_dict_subclass(type_: Any) -> bool:
     return type_ is not None and isinstance(type_, type) and issubclass(type_, Dict)
 
@@ -744,8 +982,10 @@ def is_primitive_container(obj: Any) -> bool:
 
 def get_list_element_type(ref_type: Optional[Type[Any]]) -> Any:
     args = getattr(ref_type, "__args__", None)
-    if ref_type is not List and args is not None and args[0]:
+    if ref_type is not List and args is not None:
         element_type = args[0]
+        if element_type is None:
+            element_type = NoneType
     else:
         element_type = Any
     return element_type
@@ -811,6 +1051,8 @@ def get_dict_key_value_types(ref_type: Any) -> Tuple[Any, Any]:
         if args is not None and len(args) == 2:
             key_type = args[0]
             element_type = args[1]
+            if element_type is None:
+                element_type = NoneType
         else:
             key_type = Any
             element_type = Any
@@ -1083,14 +1325,14 @@ def type_str(t: Any, include_module_name: bool = False) -> str:
         return ret
 
 
-def _ensure_container(target: Any, flags: Optional[Dict[str, bool]] = None) -> Any:
+def _ensure_container(target: Any) -> Any:
     from omegaconf import OmegaConf
 
     if is_primitive_container(target):
         assert isinstance(target, (list, tuple, dict))
-        target = OmegaConf.create(target, flags=flags)
+        target = OmegaConf.create(target)
     elif is_structured_config(target):
-        target = OmegaConf.structured(target, flags=flags)
+        target = OmegaConf.structured(target)
     elif not OmegaConf.is_config(target):
         raise ValueError(
             "Invalid input. Supports one of "