Add files using upload-large-folder tool

lib/python3.12/site-packages/omegaconf/__init__.py

@@ -0,0 +1,65 @@
+from .base import Container, DictKeyType, Node, SCMode, UnionNode
+from .dictconfig import DictConfig
+from .errors import (
+    KeyValidationError,
+    MissingMandatoryValue,
+    ReadonlyConfigError,
+    UnsupportedValueType,
+    ValidationError,
+)
+from .listconfig import ListConfig
+from .nodes import (
+    AnyNode,
+    BooleanNode,
+    BytesNode,
+    EnumNode,
+    FloatNode,
+    IntegerNode,
+    PathNode,
+    StringNode,
+    ValueNode,
+)
+from .omegaconf import (
+    II,
+    MISSING,
+    SI,
+    OmegaConf,
+    Resolver,
+    flag_override,
+    open_dict,
+    read_write,
+)
+from .version import __version__
+
+__all__ = [
+    "__version__",
+    "MissingMandatoryValue",
+    "ValidationError",
+    "ReadonlyConfigError",
+    "UnsupportedValueType",
+    "KeyValidationError",
+    "Container",
+    "UnionNode",
+    "ListConfig",
+    "DictConfig",
+    "DictKeyType",
+    "OmegaConf",
+    "Resolver",
+    "SCMode",
+    "flag_override",
+    "read_write",
+    "open_dict",
+    "Node",
+    "ValueNode",
+    "AnyNode",
+    "IntegerNode",
+    "StringNode",
+    "BytesNode",
+    "PathNode",
+    "BooleanNode",
+    "EnumNode",
+    "FloatNode",
+    "MISSING",
+    "SI",
+    "II",
+]

lib/python3.12/site-packages/omegaconf/_impl.py

@@ -0,0 +1,101 @@
+from typing import Any
+
+from omegaconf import MISSING, Container, DictConfig, ListConfig, Node, ValueNode
+from omegaconf.errors import ConfigTypeError, InterpolationToMissingValueError
+
+from ._utils import _DEFAULT_MARKER_, _get_value
+
+
+def _resolve_container_value(cfg: Container, key: Any) -> None:
+    node = cfg._get_child(key)
+    assert isinstance(node, Node)
+    if node._is_interpolation():
+        try:
+            resolved = node._dereference_node()
+        except InterpolationToMissingValueError:
+            node._set_value(MISSING)
+        else:
+            if isinstance(resolved, Container):
+                _resolve(resolved)
+            if isinstance(resolved, Container) and isinstance(node, ValueNode):
+                cfg[key] = resolved
+            else:
+                node._set_value(_get_value(resolved))
+    else:
+        _resolve(node)
+
+
+def _resolve(cfg: Node) -> Node:
+    assert isinstance(cfg, Node)
+    if cfg._is_interpolation():
+        try:
+            resolved = cfg._dereference_node()
+        except InterpolationToMissingValueError:
+            cfg._set_value(MISSING)
+        else:
+            cfg._set_value(resolved._value())
+
+    if isinstance(cfg, DictConfig):
+        for k in cfg.keys():
+            _resolve_container_value(cfg, k)
+
+    elif isinstance(cfg, ListConfig):
+        for i in range(len(cfg)):
+            _resolve_container_value(cfg, i)
+
+    return cfg
+
+
+def select_value(
+    cfg: Container,
+    key: str,
+    *,
+    default: Any = _DEFAULT_MARKER_,
+    throw_on_resolution_failure: bool = True,
+    throw_on_missing: bool = False,
+    absolute_key: bool = False,
+) -> Any:
+    node = select_node(
+        cfg=cfg,
+        key=key,
+        throw_on_resolution_failure=throw_on_resolution_failure,
+        throw_on_missing=throw_on_missing,
+        absolute_key=absolute_key,
+    )
+
+    node_not_found = node is None
+    if node_not_found or node._is_missing():
+        if default is not _DEFAULT_MARKER_:
+            return default
+        else:
+            return None
+
+    return _get_value(node)
+
+
+def select_node(
+    cfg: Container,
+    key: str,
+    *,
+    throw_on_resolution_failure: bool = True,
+    throw_on_missing: bool = False,
+    absolute_key: bool = False,
+) -> Any:
+    try:
+        # for non relative keys, the interpretation can be:
+        # 1. relative to cfg
+        # 2. relative to the config root
+        # This is controlled by the absolute_key flag. By default, such keys are relative to cfg.
+        if not absolute_key and not key.startswith("."):
+            key = f".{key}"
+
+        cfg, key = cfg._resolve_key_and_root(key)
+        _root, _last_key, node = cfg._select_impl(
+            key,
+            throw_on_missing=throw_on_missing,
+            throw_on_resolution_failure=throw_on_resolution_failure,
+        )
+    except ConfigTypeError:
+        return None
+
+    return node

lib/python3.12/site-packages/omegaconf/_utils.py

@@ -0,0 +1,1039 @@
+import copy
+import os
+import pathlib
+import re
+import string
+import sys
+import types
+import warnings
+from contextlib import contextmanager
+from enum import Enum
+from textwrap import dedent
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    get_type_hints,
+)
+
+import yaml
+
+from .errors import (
+    ConfigIndexError,
+    ConfigTypeError,
+    ConfigValueError,
+    GrammarParseError,
+    OmegaConfBaseException,
+    ValidationError,
+)
+from .grammar_parser import SIMPLE_INTERPOLATION_PATTERN, parse
+
+try:
+    import dataclasses
+
+except ImportError:  # pragma: no cover
+    dataclasses = None  # type: ignore # pragma: no cover
+
+try:
+    import attr
+
+except ImportError:  # pragma: no cover
+    attr = None  # type: ignore # pragma: no cover
+
+NoneType: Type[None] = type(None)
+
+BUILTIN_VALUE_TYPES: Tuple[Type[Any], ...] = (
+    int,
+    float,
+    bool,
+    str,
+    bytes,
+    NoneType,
+)
+
+# Regexprs to match key paths like: a.b, a[b], ..a[c].d, etc.
+# We begin by matching the head (in these examples: a, a, ..a).
+# This can be read as "dots followed by any character but `.` or `[`"
+# Note that a key starting with brackets, like [a], is purposedly *not*
+# matched here and will instead be handled in the next regex below (this
+# is to keep this regex simple).
+KEY_PATH_HEAD = re.compile(r"(\.)*[^.[]*")
+# Then we match other keys. The following expression matches one key and can
+# be read as a choice between two syntaxes:
+#   - `.` followed by anything except `.` or `[` (ex: .b, .d)
+#   - `[` followed by anything then `]` (ex: [b], [c])
+KEY_PATH_OTHER = re.compile(r"\.([^.[]*)|\[(.*?)\]")
+
+
+# source: https://yaml.org/type/bool.html
+YAML_BOOL_TYPES = [
+    "y",
+    "Y",
+    "yes",
+    "Yes",
+    "YES",
+    "n",
+    "N",
+    "no",
+    "No",
+    "NO",
+    "true",
+    "True",
+    "TRUE",
+    "false",
+    "False",
+    "FALSE",
+    "on",
+    "On",
+    "ON",
+    "off",
+    "Off",
+    "OFF",
+]
+
+
+class Marker:
+    def __init__(self, desc: str):
+        self.desc = desc
+
+    def __repr__(self) -> str:
+        return self.desc
+
+
+# To be used as default value when `None` is not an option.
+_DEFAULT_MARKER_: Any = Marker("_DEFAULT_MARKER_")
+
+
+class OmegaConfDumper(yaml.Dumper):  # type: ignore
+    str_representer_added = False
+
+    @staticmethod
+    def str_representer(dumper: yaml.Dumper, data: str) -> yaml.ScalarNode:
+        with_quotes = yaml_is_bool(data) or is_int(data) or is_float(data)
+        return dumper.represent_scalar(
+            yaml.resolver.BaseResolver.DEFAULT_SCALAR_TAG,
+            data,
+            style=("'" if with_quotes else None),
+        )
+
+
+def get_omega_conf_dumper() -> Type[OmegaConfDumper]:
+    if not OmegaConfDumper.str_representer_added:
+        OmegaConfDumper.add_representer(str, OmegaConfDumper.str_representer)
+        OmegaConfDumper.str_representer_added = True
+    return OmegaConfDumper
+
+
+def yaml_is_bool(b: str) -> bool:
+    return b in YAML_BOOL_TYPES
+
+
+def get_yaml_loader() -> Any:
+    class OmegaConfLoader(yaml.SafeLoader):  # type: ignore
+        def construct_mapping(self, node: yaml.Node, deep: bool = False) -> Any:
+            keys = set()
+            for key_node, value_node in node.value:
+                if key_node.tag != yaml.resolver.BaseResolver.DEFAULT_SCALAR_TAG:
+                    continue
+                if key_node.value in keys:
+                    raise yaml.constructor.ConstructorError(
+                        "while constructing a mapping",
+                        node.start_mark,
+                        f"found duplicate key {key_node.value}",
+                        key_node.start_mark,
+                    )
+                keys.add(key_node.value)
+            return super().construct_mapping(node, deep=deep)
+
+    loader = OmegaConfLoader
+    loader.add_implicit_resolver(
+        "tag:yaml.org,2002:float",
+        re.compile(
+            """^(?:
+         [-+]?[0-9]+(?:_[0-9]+)*\\.[0-9_]*(?:[eE][-+]?[0-9]+)?
+        |[-+]?[0-9]+(?:_[0-9]+)*(?:[eE][-+]?[0-9]+)
+        |\\.[0-9]+(?:_[0-9]+)*(?:[eE][-+][0-9]+)?
+        |[-+]?[0-9]+(?:_[0-9]+)*(?::[0-5]?[0-9])+\\.[0-9_]*
+        |[-+]?\\.(?:inf|Inf|INF)
+        |\\.(?:nan|NaN|NAN))$""",
+            re.X,
+        ),
+        list("-+0123456789."),
+    )
+    loader.yaml_implicit_resolvers = {
+        key: [
+            (tag, regexp)
+            for tag, regexp in resolvers
+            if tag != "tag:yaml.org,2002:timestamp"
+        ]
+        for key, resolvers in loader.yaml_implicit_resolvers.items()
+    }
+
+    loader.add_constructor(
+        "tag:yaml.org,2002:python/object/apply:pathlib.Path",
+        lambda loader, node: pathlib.Path(*loader.construct_sequence(node)),
+    )
+    loader.add_constructor(
+        "tag:yaml.org,2002:python/object/apply:pathlib.PosixPath",
+        lambda loader, node: pathlib.PosixPath(*loader.construct_sequence(node)),
+    )
+    loader.add_constructor(
+        "tag:yaml.org,2002:python/object/apply:pathlib.WindowsPath",
+        lambda loader, node: pathlib.WindowsPath(*loader.construct_sequence(node)),
+    )
+
+    return loader
+
+
+def _get_class(path: str) -> type:
+    from importlib import import_module
+
+    module_path, _, class_name = path.rpartition(".")
+    mod = import_module(module_path)
+    try:
+        klass: type = getattr(mod, class_name)
+    except AttributeError:
+        raise ImportError(f"Class {class_name} is not in module {module_path}")
+    return klass
+
+
+def is_union_annotation(type_: Any) -> bool:
+    if sys.version_info >= (3, 10):  # pragma: no cover
+        if isinstance(type_, types.UnionType):
+            return True
+    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."""
+    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
+        if len(args) == 1:
+            return optional, args[0]
+        elif len(args) >= 2:
+            return optional, Union[args]
+        else:
+            assert False
+
+    if type_ is Any:
+        return True, Any
+
+    if type_ in (None, NoneType):
+        return True, NoneType
+
+    return False, type_
+
+
+def _is_optional(obj: Any, key: Optional[Union[int, str]] = None) -> bool:
+    """Check `obj` metadata to see if the given node is optional."""
+    from .base import Container, Node
+
+    if key is not None:
+        assert isinstance(obj, Container)
+        obj = obj._get_node(key)
+    assert isinstance(obj, Node)
+    return obj._is_optional()
+
+
+def _resolve_forward(type_: Type[Any], module: str) -> Type[Any]:
+    import typing  # lgtm [py/import-and-import-from]
+
+    forward = typing.ForwardRef if hasattr(typing, "ForwardRef") else typing._ForwardRef  # type: ignore
+    if type(type_) is forward:
+        return _get_class(f"{module}.{type_.__forward_arg__}")
+    else:
+        if is_dict_annotation(type_):
+            kt, vt = get_dict_key_value_types(type_)
+            if kt is not None:
+                kt = _resolve_forward(kt, module=module)
+            if vt is not None:
+                vt = _resolve_forward(vt, module=module)
+            return Dict[kt, vt]  # type: ignore
+        if is_list_annotation(type_):
+            et = get_list_element_type(type_)
+            if et is not None:
+                et = _resolve_forward(et, module=module)
+            return List[et]  # type: ignore
+        if is_tuple_annotation(type_):
+            its = get_tuple_item_types(type_)
+            its = tuple(_resolve_forward(it, module=module) for it in its)
+            return Tuple[its]  # type: ignore
+
+        return type_
+
+
+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 get_attr_class_fields(obj: Any) -> List["attr.Attribute[Any]"]:
+    is_type = isinstance(obj, type)
+    obj_type = obj if is_type else type(obj)
+    fields = attr.fields_dict(obj_type).values()
+    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]:
+    from omegaconf.omegaconf import OmegaConf, _maybe_wrap
+
+    flags = {"allow_objects": allow_objects} if allow_objects is not None else {}
+
+    from omegaconf import MISSING
+
+    d = {}
+    is_type = isinstance(obj, type)
+    obj_type = obj if is_type else type(obj)
+    dummy_parent = OmegaConf.create({}, flags=flags)
+    dummy_parent._metadata.object_type = obj_type
+    resolved_hints = get_type_hints(obj_type)
+
+    for attrib in get_attr_class_fields(obj):
+        name = attrib.name
+        is_optional, type_ = _resolve_optional(resolved_hints[name])
+        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_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 get_dataclass_fields(obj: Any) -> List["dataclasses.Field[Any]"]:
+    fields = dataclasses.fields(obj)
+    return [f for f in fields if f.metadata.get("omegaconf_ignore") is not True]
+
+
+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 get_dataclass_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
+
+        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 is_dataclass(obj: Any) -> bool:
+    from omegaconf.base import Node
+
+    if dataclasses is None or isinstance(obj, Node):
+        return False
+    return dataclasses.is_dataclass(obj)
+
+
+def is_attr_class(obj: Any) -> bool:
+    from omegaconf.base import Node
+
+    if attr is None or isinstance(obj, Node):
+        return False
+    return attr.has(obj)
+
+
+def is_structured_config(obj: Any) -> bool:
+    return is_attr_class(obj) or is_dataclass(obj)
+
+
+def is_dataclass_frozen(type_: Any) -> bool:
+    return type_.__dataclass_params__.frozen  # type: ignore
+
+
+def is_attr_frozen(type_: type) -> bool:
+    # This is very hacky and probably fragile as well.
+    # Unfortunately currently there isn't an official API in attr that can detect that.
+    # noinspection PyProtectedMember
+    return type_.__setattr__ == attr._make._frozen_setattrs  # type: ignore
+
+
+def get_type_of(class_or_object: Any) -> Type[Any]:
+    type_ = class_or_object
+    if not isinstance(type_, type):
+        type_ = type(class_or_object)
+    assert isinstance(type_, type)
+    return type_
+
+
+def is_structured_config_frozen(obj: Any) -> bool:
+    type_ = get_type_of(obj)
+
+    if is_dataclass(type_):
+        return is_dataclass_frozen(type_)
+    if is_attr_class(type_):
+        return is_attr_frozen(type_)
+    return False
+
+
+def get_structured_config_init_field_names(obj: Any) -> List[str]:
+    fields: Union[List["dataclasses.Field[Any]"], List["attr.Attribute[Any]"]]
+    if is_dataclass(obj):
+        fields = get_dataclass_fields(obj)
+    elif is_attr_class(obj):
+        fields = get_attr_class_fields(obj)
+    else:
+        raise ValueError(f"Unsupported type: {type(obj).__name__}")
+    return [f.name for f in fields if f.init]
+
+
+def get_structured_config_data(
+    obj: Any, allow_objects: Optional[bool] = None
+) -> Dict[str, Any]:
+    if is_dataclass(obj):
+        return get_dataclass_data(obj, allow_objects=allow_objects)
+    elif is_attr_class(obj):
+        return get_attr_data(obj, allow_objects=allow_objects)
+    else:
+        raise ValueError(f"Unsupported type: {type(obj).__name__}")
+
+
+class ValueKind(Enum):
+    VALUE = 0
+    MANDATORY_MISSING = 1
+    INTERPOLATION = 2
+
+
+def _is_missing_value(value: Any) -> bool:
+    from omegaconf import Node
+
+    if isinstance(value, Node):
+        value = value._value()
+    return _is_missing_literal(value)
+
+
+def _is_missing_literal(value: Any) -> bool:
+    # Uses literal '???' instead of the MISSING const for performance reasons.
+    return isinstance(value, str) and value == "???"
+
+
+def _is_none(
+    value: Any, resolve: bool = False, throw_on_resolution_failure: bool = True
+) -> bool:
+    from omegaconf import Node
+
+    if not isinstance(value, Node):
+        return value is None
+
+    if resolve:
+        value = value._maybe_dereference_node(
+            throw_on_resolution_failure=throw_on_resolution_failure
+        )
+        if not throw_on_resolution_failure and value is None:
+            # Resolution failure: consider that it is *not* None.
+            return False
+        assert isinstance(value, Node)
+
+    return value._is_none()
+
+
+def get_value_kind(
+    value: Any, strict_interpolation_validation: bool = False
+) -> ValueKind:
+    """
+    Determine the kind of a value
+    Examples:
+    VALUE: "10", "20", True
+    MANDATORY_MISSING: "???"
+    INTERPOLATION: "${foo.bar}", "${foo.${bar}}", "${foo:bar}", "[${foo}, ${bar}]",
+                   "ftp://${host}/path", "${foo:${bar}, [true], {'baz': ${baz}}}"
+
+    :param value: Input to classify.
+    :param strict_interpolation_validation: If `True`, then when `value` is a string
+        containing "${", it is parsed to validate the interpolation syntax. If `False`,
+        this parsing step is skipped: this is more efficient, but will not detect errors.
+    """
+
+    if _is_missing_value(value):
+        return ValueKind.MANDATORY_MISSING
+
+    if _is_interpolation(value, strict_interpolation_validation):
+        return ValueKind.INTERPOLATION
+
+    return ValueKind.VALUE
+
+
+def _is_interpolation(v: Any, strict_interpolation_validation: bool = False) -> bool:
+    from omegaconf import Node
+
+    if isinstance(v, Node):
+        v = v._value()
+
+    if isinstance(v, str) and _is_interpolation_string(
+        v, strict_interpolation_validation
+    ):
+        return True
+    return False
+
+
+def _is_interpolation_string(value: str, strict_interpolation_validation: bool) -> bool:
+    # We identify potential interpolations by the presence of "${" in the string.
+    # Note that escaped interpolations (ex: "esc: \${bar}") are identified as
+    # interpolations: this is intended, since they must be processed as interpolations
+    # for the string to be properly un-escaped.
+    # Keep in mind that invalid interpolations will only be detected when
+    # `strict_interpolation_validation` is True.
+    if "${" in value:
+        if strict_interpolation_validation:
+            # First try the cheap regex matching that detects common interpolations.
+            if SIMPLE_INTERPOLATION_PATTERN.match(value) is None:
+                # If no match, do the more expensive grammar parsing to detect errors.
+                parse(value)
+        return True
+    return False
+
+
+def _is_special(value: Any) -> bool:
+    """Special values are None, MISSING, and interpolation."""
+    return _is_none(value) or get_value_kind(value) in (
+        ValueKind.MANDATORY_MISSING,
+        ValueKind.INTERPOLATION,
+    )
+
+
+def is_float(st: str) -> bool:
+    try:
+        float(st)
+        return True
+    except ValueError:
+        return False
+
+
+def is_int(st: str) -> bool:
+    try:
+        int(st)
+        return True
+    except ValueError:
+        return False
+
+
+def is_primitive_list(obj: Any) -> bool:
+    return isinstance(obj, (list, tuple))
+
+
+def is_primitive_dict(obj: Any) -> bool:
+    t = get_type_of(obj)
+    return t is dict
+
+
+def is_dict_annotation(type_: Any) -> bool:
+    if type_ in (dict, Dict):
+        return True
+    origin = getattr(type_, "__origin__", None)
+    # type_dict is a bit hard to detect.
+    # this support is tentative, if it eventually causes issues in other areas it may be dropped.
+    if sys.version_info < (3, 7, 0):  # pragma: no cover
+        typed_dict = hasattr(type_, "__base__") and type_.__base__ == Dict
+        return origin is Dict or type_ is Dict or typed_dict
+    else:  # pragma: no cover
+        typed_dict = hasattr(type_, "__base__") and type_.__base__ == dict
+        return origin is dict or typed_dict
+
+
+def is_list_annotation(type_: Any) -> bool:
+    if type_ in (list, List):
+        return True
+    origin = getattr(type_, "__origin__", None)
+    if sys.version_info < (3, 7, 0):
+        return origin is List or type_ is List  # pragma: no cover
+    else:
+        return origin is list  # pragma: no cover
+
+
+def is_tuple_annotation(type_: Any) -> bool:
+    if type_ in (tuple, Tuple):
+        return True
+    origin = getattr(type_, "__origin__", None)
+    if sys.version_info < (3, 7, 0):
+        return origin is Tuple or type_ is Tuple  # pragma: no cover
+    else:
+        return origin is tuple  # pragma: no cover
+
+
+def is_supported_union_annotation(obj: Any) -> bool:
+    """Currently only primitive types are supported in Unions, e.g. Union[int, str]"""
+    if not is_union_annotation(obj):
+        return False
+    args = obj.__args__
+    return all(is_primitive_type_annotation(arg) for arg in args)
+
+
+def is_dict_subclass(type_: Any) -> bool:
+    return type_ is not None and isinstance(type_, type) and issubclass(type_, Dict)
+
+
+def is_dict(obj: Any) -> bool:
+    return is_primitive_dict(obj) or is_dict_annotation(obj) or is_dict_subclass(obj)
+
+
+def is_primitive_container(obj: Any) -> bool:
+    return is_primitive_list(obj) or is_primitive_dict(obj)
+
+
+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]:
+        element_type = args[0]
+    else:
+        element_type = Any
+    return element_type
+
+
+def get_tuple_item_types(ref_type: Type[Any]) -> Tuple[Any, ...]:
+    args = getattr(ref_type, "__args__", None)
+    if args in (None, ()):
+        args = (Any, ...)
+    assert isinstance(args, tuple)
+    return args
+
+
+def get_dict_key_value_types(ref_type: Any) -> Tuple[Any, Any]:
+    args = getattr(ref_type, "__args__", None)
+    if args is None:
+        bases = getattr(ref_type, "__orig_bases__", None)
+        if bases is not None and len(bases) > 0:
+            args = getattr(bases[0], "__args__", None)
+
+    key_type: Any
+    element_type: Any
+    if ref_type is None or ref_type == Dict:
+        key_type = Any
+        element_type = Any
+    else:
+        if args is not None:
+            key_type = args[0]
+            element_type = args[1]
+        else:
+            key_type = Any
+            element_type = Any
+
+    return key_type, element_type
+
+
+def is_valid_value_annotation(type_: Any) -> bool:
+    _, type_ = _resolve_optional(type_)
+    return (
+        type_ is Any
+        or is_primitive_type_annotation(type_)
+        or is_structured_config(type_)
+        or is_container_annotation(type_)
+        or is_supported_union_annotation(type_)
+    )
+
+
+def _valid_dict_key_annotation_type(type_: Any) -> bool:
+    from omegaconf import DictKeyType
+
+    return type_ is None or type_ is Any or issubclass(type_, DictKeyType.__args__)  # type: ignore
+
+
+def is_primitive_type_annotation(type_: Any) -> bool:
+    type_ = get_type_of(type_)
+    return issubclass(type_, (Enum, pathlib.Path)) or type_ in BUILTIN_VALUE_TYPES
+
+
+def _get_value(value: Any) -> Any:
+    from .base import Container, UnionNode
+    from .nodes import ValueNode
+
+    if isinstance(value, ValueNode):
+        return value._value()
+    elif isinstance(value, Container):
+        boxed = value._value()
+        if boxed is None or _is_missing_literal(boxed) or _is_interpolation(boxed):
+            return boxed
+    elif isinstance(value, UnionNode):
+        boxed = value._value()
+        if boxed is None or _is_missing_literal(boxed) or _is_interpolation(boxed):
+            return boxed
+        else:
+            return _get_value(boxed)  # pass through value of boxed node
+
+    # return primitives and regular OmegaConf Containers as is
+    return value
+
+
+def get_type_hint(obj: Any, key: Any = None) -> Optional[Type[Any]]:
+    from omegaconf import Container, Node
+
+    if isinstance(obj, Container):
+        if key is not None:
+            obj = obj._get_node(key)
+    else:
+        if key is not None:
+            raise ValueError("Key must only be provided when obj is a container")
+
+    if isinstance(obj, Node):
+        ref_type = obj._metadata.ref_type
+        if obj._is_optional() and ref_type is not Any:
+            return Optional[ref_type]  # type: ignore
+        else:
+            return ref_type
+    else:
+        return Any  # type: ignore
+
+
+def _raise(ex: Exception, cause: Exception) -> None:
+    # Set the environment variable OC_CAUSE=1 to get a stacktrace that includes the
+    # causing exception.
+    env_var = os.environ["OC_CAUSE"] if "OC_CAUSE" in os.environ else None
+    debugging = sys.gettrace() is not None
+    full_backtrace = (debugging and not env_var == "0") or (env_var == "1")
+    if full_backtrace:
+        ex.__cause__ = cause
+    else:
+        ex.__cause__ = None
+    raise ex.with_traceback(sys.exc_info()[2])  # set env var OC_CAUSE=1 for full trace
+
+
+def format_and_raise(
+    node: Any,
+    key: Any,
+    value: Any,
+    msg: str,
+    cause: Exception,
+    type_override: Any = None,
+) -> None:
+    from omegaconf import OmegaConf
+    from omegaconf.base import Node
+
+    if isinstance(cause, AssertionError):
+        raise
+
+    if isinstance(cause, OmegaConfBaseException) and cause._initialized:
+        ex = cause
+        if type_override is not None:
+            ex = type_override(str(cause))
+            ex.__dict__ = copy.deepcopy(cause.__dict__)
+        _raise(ex, cause)
+
+    object_type: Optional[Type[Any]]
+    object_type_str: Optional[str] = None
+    ref_type: Optional[Type[Any]]
+    ref_type_str: Optional[str]
+
+    child_node: Optional[Node] = None
+    if node is None:
+        full_key = key if key is not None else ""
+        object_type = None
+        ref_type = None
+        ref_type_str = None
+    else:
+        if key is not None and not node._is_none():
+            child_node = node._get_node(key, validate_access=False)
+
+        try:
+            full_key = node._get_full_key(key=key)
+        except Exception as exc:
+            # Since we are handling an exception, raising a different one here would
+            # be misleading. Instead, we display it in the key.
+            full_key = f"<unresolvable due to {type(exc).__name__}: {exc}>"
+
+        object_type = OmegaConf.get_type(node)
+        object_type_str = type_str(object_type)
+
+        ref_type = get_type_hint(node)
+        ref_type_str = type_str(ref_type)
+
+    msg = string.Template(msg).safe_substitute(
+        REF_TYPE=ref_type_str,
+        OBJECT_TYPE=object_type_str,
+        KEY=key,
+        FULL_KEY=full_key,
+        VALUE=value,
+        VALUE_TYPE=type_str(type(value), include_module_name=True),
+        KEY_TYPE=f"{type(key).__name__}",
+    )
+
+    if ref_type not in (None, Any):
+        template = dedent(
+            """\
+            $MSG
+                full_key: $FULL_KEY
+                reference_type=$REF_TYPE
+                object_type=$OBJECT_TYPE"""
+        )
+    else:
+        template = dedent(
+            """\
+            $MSG
+                full_key: $FULL_KEY
+                object_type=$OBJECT_TYPE"""
+        )
+    s = string.Template(template=template)
+
+    message = s.substitute(
+        REF_TYPE=ref_type_str, OBJECT_TYPE=object_type_str, MSG=msg, FULL_KEY=full_key
+    )
+    exception_type = type(cause) if type_override is None else type_override
+    if exception_type == TypeError:
+        exception_type = ConfigTypeError
+    elif exception_type == IndexError:
+        exception_type = ConfigIndexError
+
+    ex = exception_type(f"{message}")
+    if issubclass(exception_type, OmegaConfBaseException):
+        ex._initialized = True
+        ex.msg = message
+        ex.parent_node = node
+        ex.child_node = child_node
+        ex.key = key
+        ex.full_key = full_key
+        ex.value = value
+        ex.object_type = object_type
+        ex.object_type_str = object_type_str
+        ex.ref_type = ref_type
+        ex.ref_type_str = ref_type_str
+
+    _raise(ex, cause)
+
+
+def type_str(t: Any, include_module_name: bool = False) -> str:
+    is_optional, t = _resolve_optional(t)
+    if t is NoneType:
+        return str(t.__name__)
+    if t is Any:
+        return "Any"
+    if t is ...:
+        return "..."
+
+    if hasattr(t, "__name__"):
+        name = str(t.__name__)
+    elif getattr(t, "_name", None) is not None:  # pragma: no cover
+        name = str(t._name)
+    elif getattr(t, "__origin__", None) is not None:  # pragma: no cover
+        name = type_str(t.__origin__)
+    else:
+        name = str(t)
+        if name.startswith("typing."):  # pragma: no cover
+            name = name[len("typing.") :]
+
+    args = getattr(t, "__args__", None)
+    if args is not None:
+        args = ", ".join(
+            [type_str(t, include_module_name=include_module_name) for t in t.__args__]
+        )
+        ret = f"{name}[{args}]"
+    else:
+        ret = name
+    if include_module_name:
+        if (
+            hasattr(t, "__module__")
+            and t.__module__ != "builtins"
+            and t.__module__ != "typing"
+            and not t.__module__.startswith("omegaconf.")
+        ):
+            module_prefix = str(t.__module__) + "."
+        else:
+            module_prefix = ""
+        ret = module_prefix + ret
+    if is_optional:
+        return f"Optional[{ret}]"
+    else:
+        return ret
+
+
+def _ensure_container(target: Any, flags: Optional[Dict[str, bool]] = None) -> Any:
+    from omegaconf import OmegaConf
+
+    if is_primitive_container(target):
+        assert isinstance(target, (list, dict))
+        target = OmegaConf.create(target, flags=flags)
+    elif is_structured_config(target):
+        target = OmegaConf.structured(target, flags=flags)
+    elif not OmegaConf.is_config(target):
+        raise ValueError(
+            "Invalid input. Supports one of "
+            + "[dict,list,DictConfig,ListConfig,dataclass,dataclass instance,attr class,attr class instance]"
+        )
+
+    return target
+
+
+def is_generic_list(type_: Any) -> bool:
+    """
+    Checks if a type is a generic list, for example:
+    list returns False
+    typing.List returns False
+    typing.List[T] returns True
+
+    :param type_: variable type
+    :return: bool
+    """
+    return is_list_annotation(type_) and get_list_element_type(type_) is not None
+
+
+def is_generic_dict(type_: Any) -> bool:
+    """
+    Checks if a type is a generic dict, for example:
+    list returns False
+    typing.List returns False
+    typing.List[T] returns True
+
+    :param type_: variable type
+    :return: bool
+    """
+    return is_dict_annotation(type_) and len(get_dict_key_value_types(type_)) > 0
+
+
+def is_container_annotation(type_: Any) -> bool:
+    return is_list_annotation(type_) or is_dict_annotation(type_)
+
+
+def split_key(key: str) -> List[str]:
+    """
+    Split a full key path into its individual components.
+
+    This is similar to `key.split(".")` but also works with the getitem syntax:
+        "a.b"       -> ["a", "b"]
+        "a[b]"      -> ["a", "b"]
+        ".a.b[c].d" -> ["", "a", "b", "c", "d"]
+        "[a].b"     -> ["a", "b"]
+    """
+    # Obtain the first part of the key (in docstring examples: a, a, .a, '')
+    first = KEY_PATH_HEAD.match(key)
+    assert first is not None
+    first_stop = first.span()[1]
+
+    # `tokens` will contain all elements composing the key.
+    tokens = key[0:first_stop].split(".")
+
+    # Optimization in case `key` has no other component: we are done.
+    if first_stop == len(key):
+        return tokens
+
+    if key[first_stop] == "[" and not tokens[-1]:
+        # This is a special case where the first key starts with brackets, e.g.
+        # [a] or ..[a]. In that case there is an extra "" in `tokens` that we
+        # need to get rid of:
+        #   [a]   -> tokens = [""] but we would like []
+        #   ..[a] -> tokens = ["", "", ""] but we would like ["", ""]
+        tokens.pop()
+
+    # Identify other key elements (in docstring examples: b, b, b/c/d, b)
+    others = KEY_PATH_OTHER.findall(key[first_stop:])
+
+    # There are two groups in the `KEY_PATH_OTHER` regex: one for keys starting
+    # with a dot (.b, .d) and one for keys starting with a bracket ([b], [c]).
+    # Only one group can be non-empty.
+    tokens += [dot_key if dot_key else bracket_key for dot_key, bracket_key in others]
+
+    return tokens
+
+
+# Similar to Python 3.7+'s `contextlib.nullcontext` (which should be used instead,
+# once support for Python 3.6 is dropped).
+@contextmanager
+def nullcontext(enter_result: Any = None) -> Iterator[Any]:
+    yield enter_result

lib/python3.12/site-packages/omegaconf/base.py

@@ -0,0 +1,962 @@
+import copy
+import sys
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Type, Union
+
+from antlr4 import ParserRuleContext
+
+from ._utils import (
+    _DEFAULT_MARKER_,
+    NoneType,
+    ValueKind,
+    _get_value,
+    _is_interpolation,
+    _is_missing_value,
+    _is_special,
+    format_and_raise,
+    get_value_kind,
+    is_union_annotation,
+    is_valid_value_annotation,
+    split_key,
+    type_str,
+)
+from .errors import (
+    ConfigKeyError,
+    ConfigTypeError,
+    InterpolationKeyError,
+    InterpolationResolutionError,
+    InterpolationToMissingValueError,
+    InterpolationValidationError,
+    MissingMandatoryValue,
+    UnsupportedInterpolationType,
+    ValidationError,
+)
+from .grammar.gen.OmegaConfGrammarParser import OmegaConfGrammarParser
+from .grammar_parser import parse
+from .grammar_visitor import GrammarVisitor
+
+DictKeyType = Union[str, bytes, int, Enum, float, bool]
+
+
+@dataclass
+class Metadata:
+
+    ref_type: Union[Type[Any], Any]
+
+    object_type: Union[Type[Any], Any]
+
+    optional: bool
+
+    key: Any
+
+    # Flags have 3 modes:
+    #   unset : inherit from parent (None if no parent specifies)
+    #   set to true: flag is true
+    #   set to false: flag is false
+    flags: Optional[Dict[str, bool]] = None
+
+    # If True, when checking the value of a flag, if the flag is not set None is returned
+    # otherwise, the parent node is queried.
+    flags_root: bool = False
+
+    resolver_cache: Dict[str, Any] = field(default_factory=lambda: defaultdict(dict))
+
+    def __post_init__(self) -> None:
+        if self.flags is None:
+            self.flags = {}
+
+    @property
+    def type_hint(self) -> Union[Type[Any], Any]:
+        """Compute `type_hint` from `self.optional` and `self.ref_type`"""
+        # For compatibility with pickled OmegaConf objects created using older
+        # versions of OmegaConf, we store `ref_type` and `object_type`
+        # separately (rather than storing `type_hint` directly).
+        if self.optional:
+            return Optional[self.ref_type]
+        else:
+            return self.ref_type
+
+
+@dataclass
+class ContainerMetadata(Metadata):
+    key_type: Any = None
+    element_type: Any = None
+
+    def __post_init__(self) -> None:
+        if self.ref_type is None:
+            self.ref_type = Any
+        assert self.key_type is Any or isinstance(self.key_type, type)
+        if self.element_type is not None:
+            if not is_valid_value_annotation(self.element_type):
+                raise ValidationError(
+                    f"Unsupported value type: '{type_str(self.element_type, include_module_name=True)}'"
+                )
+
+        if self.flags is None:
+            self.flags = {}
+
+
+class Node(ABC):
+    _metadata: Metadata
+
+    _parent: Optional["Box"]
+    _flags_cache: Optional[Dict[str, Optional[bool]]]
+
+    def __init__(self, parent: Optional["Box"], metadata: Metadata):
+        self.__dict__["_metadata"] = metadata
+        self.__dict__["_parent"] = parent
+        self.__dict__["_flags_cache"] = None
+
+    def __getstate__(self) -> Dict[str, Any]:
+        # Overridden to ensure that the flags cache is cleared on serialization.
+        state_dict = copy.copy(self.__dict__)
+        del state_dict["_flags_cache"]
+        return state_dict
+
+    def __setstate__(self, state_dict: Dict[str, Any]) -> None:
+        self.__dict__.update(state_dict)
+        self.__dict__["_flags_cache"] = None
+
+    def _set_parent(self, parent: Optional["Box"]) -> None:
+        assert parent is None or isinstance(parent, Box)
+        self.__dict__["_parent"] = parent
+        self._invalidate_flags_cache()
+
+    def _invalidate_flags_cache(self) -> None:
+        self.__dict__["_flags_cache"] = None
+
+    def _get_parent(self) -> Optional["Box"]:
+        parent = self.__dict__["_parent"]
+        assert parent is None or isinstance(parent, Box)
+        return parent
+
+    def _get_parent_container(self) -> Optional["Container"]:
+        """
+        Like _get_parent, but returns the grandparent
+        in the case where `self` is wrapped by a UnionNode.
+        """
+        parent = self.__dict__["_parent"]
+        assert parent is None or isinstance(parent, Box)
+
+        if isinstance(parent, UnionNode):
+            grandparent = parent.__dict__["_parent"]
+            assert grandparent is None or isinstance(grandparent, Container)
+            return grandparent
+        else:
+            assert parent is None or isinstance(parent, Container)
+            return parent
+
+    def _set_flag(
+        self,
+        flags: Union[List[str], str],
+        values: Union[List[Optional[bool]], Optional[bool]],
+    ) -> "Node":
+        if isinstance(flags, str):
+            flags = [flags]
+
+        if values is None or isinstance(values, bool):
+            values = [values]
+
+        if len(values) == 1:
+            values = len(flags) * values
+
+        if len(flags) != len(values):
+            raise ValueError("Inconsistent lengths of input flag names and values")
+
+        for idx, flag in enumerate(flags):
+            value = values[idx]
+            if value is None:
+                assert self._metadata.flags is not None
+                if flag in self._metadata.flags:
+                    del self._metadata.flags[flag]
+            else:
+                assert self._metadata.flags is not None
+                self._metadata.flags[flag] = value
+        self._invalidate_flags_cache()
+        return self
+
+    def _get_node_flag(self, flag: str) -> Optional[bool]:
+        """
+        :param flag: flag to inspect
+        :return: the state of the flag on this node.
+        """
+        assert self._metadata.flags is not None
+        return self._metadata.flags.get(flag)
+
+    def _get_flag(self, flag: str) -> Optional[bool]:
+        cache = self.__dict__["_flags_cache"]
+        if cache is None:
+            cache = self.__dict__["_flags_cache"] = {}
+
+        ret = cache.get(flag, _DEFAULT_MARKER_)
+        if ret is _DEFAULT_MARKER_:
+            ret = self._get_flag_no_cache(flag)
+            cache[flag] = ret
+        assert ret is None or isinstance(ret, bool)
+        return ret
+
+    def _get_flag_no_cache(self, flag: str) -> Optional[bool]:
+        """
+        Returns True if this config node flag is set
+        A flag is set if node.set_flag(True) was called
+        or one if it's parents is flag is set
+        :return:
+        """
+        flags = self._metadata.flags
+        assert flags is not None
+        if flag in flags and flags[flag] is not None:
+            return flags[flag]
+
+        if self._is_flags_root():
+            return None
+
+        parent = self._get_parent()
+        if parent is None:
+            return None
+        else:
+            # noinspection PyProtectedMember
+            return parent._get_flag(flag)
+
+    def _format_and_raise(
+        self,
+        key: Any,
+        value: Any,
+        cause: Exception,
+        msg: Optional[str] = None,
+        type_override: Any = None,
+    ) -> None:
+        format_and_raise(
+            node=self,
+            key=key,
+            value=value,
+            msg=str(cause) if msg is None else msg,
+            cause=cause,
+            type_override=type_override,
+        )
+        assert False
+
+    @abstractmethod
+    def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str:
+        ...
+
+    def _dereference_node(self) -> "Node":
+        node = self._dereference_node_impl(throw_on_resolution_failure=True)
+        assert node is not None
+        return node
+
+    def _maybe_dereference_node(
+        self,
+        throw_on_resolution_failure: bool = False,
+        memo: Optional[Set[int]] = None,
+    ) -> Optional["Node"]:
+        return self._dereference_node_impl(
+            throw_on_resolution_failure=throw_on_resolution_failure,
+            memo=memo,
+        )
+
+    def _dereference_node_impl(
+        self,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]] = None,
+    ) -> Optional["Node"]:
+        if not self._is_interpolation():
+            return self
+
+        parent = self._get_parent_container()
+        if parent is None:
+            if throw_on_resolution_failure:
+                raise InterpolationResolutionError(
+                    "Cannot resolve interpolation for a node without a parent"
+                )
+            return None
+        assert parent is not None
+        key = self._key()
+        return parent._resolve_interpolation_from_parse_tree(
+            parent=parent,
+            key=key,
+            value=self,
+            parse_tree=parse(_get_value(self)),
+            throw_on_resolution_failure=throw_on_resolution_failure,
+            memo=memo,
+        )
+
+    def _get_root(self) -> "Container":
+        root: Optional[Box] = self._get_parent()
+        if root is None:
+            assert isinstance(self, Container)
+            return self
+        assert root is not None and isinstance(root, Box)
+        while root._get_parent() is not None:
+            root = root._get_parent()
+            assert root is not None and isinstance(root, Box)
+        assert root is not None and isinstance(root, Container)
+        return root
+
+    def _is_missing(self) -> bool:
+        """
+        Check if the node's value is `???` (does *not* resolve interpolations).
+        """
+        return _is_missing_value(self)
+
+    def _is_none(self) -> bool:
+        """
+        Check if the node's value is `None` (does *not* resolve interpolations).
+        """
+        return self._value() is None
+
+    @abstractmethod
+    def __eq__(self, other: Any) -> bool:
+        ...
+
+    @abstractmethod
+    def __ne__(self, other: Any) -> bool:
+        ...
+
+    @abstractmethod
+    def __hash__(self) -> int:
+        ...
+
+    @abstractmethod
+    def _value(self) -> Any:
+        ...
+
+    @abstractmethod
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        ...
+
+    @abstractmethod
+    def _is_optional(self) -> bool:
+        ...
+
+    @abstractmethod
+    def _is_interpolation(self) -> bool:
+        ...
+
+    def _key(self) -> Any:
+        return self._metadata.key
+
+    def _set_key(self, key: Any) -> None:
+        self._metadata.key = key
+
+    def _is_flags_root(self) -> bool:
+        return self._metadata.flags_root
+
+    def _set_flags_root(self, flags_root: bool) -> None:
+        if self._metadata.flags_root != flags_root:
+            self._metadata.flags_root = flags_root
+            self._invalidate_flags_cache()
+
+    def _has_ref_type(self) -> bool:
+        return self._metadata.ref_type is not Any
+
+
+class Box(Node):
+    """
+    Base class for nodes that can contain other nodes.
+    Concrete subclasses include DictConfig, ListConfig, and UnionNode.
+    """
+
+    _content: Any
+
+    def __init__(self, parent: Optional["Box"], metadata: Metadata):
+        super().__init__(parent=parent, metadata=metadata)
+        self.__dict__["_content"] = None
+
+    def __copy__(self) -> Any:
+        # real shallow copy is impossible because of the reference to the parent.
+        return copy.deepcopy(self)
+
+    def _re_parent(self) -> None:
+        from .dictconfig import DictConfig
+        from .listconfig import ListConfig
+
+        # update parents of first level Config nodes to self
+
+        if isinstance(self, DictConfig):
+            content = self.__dict__["_content"]
+            if isinstance(content, dict):
+                for _key, value in self.__dict__["_content"].items():
+                    if value is not None:
+                        value._set_parent(self)
+                    if isinstance(value, Box):
+                        value._re_parent()
+        elif isinstance(self, ListConfig):
+            content = self.__dict__["_content"]
+            if isinstance(content, list):
+                for item in self.__dict__["_content"]:
+                    if item is not None:
+                        item._set_parent(self)
+                    if isinstance(item, Box):
+                        item._re_parent()
+        elif isinstance(self, UnionNode):
+            content = self.__dict__["_content"]
+            if isinstance(content, Node):
+                content._set_parent(self)
+                if isinstance(content, Box):  # pragma: no cover
+                    # No coverage here as support for containers inside
+                    # UnionNode is not yet implemented
+                    content._re_parent()
+
+
+class Container(Box):
+    """
+    Container tagging interface
+    """
+
+    _metadata: ContainerMetadata
+
+    @abstractmethod
+    def _get_child(
+        self,
+        key: Any,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Union[Optional[Node], List[Optional[Node]]]:
+        ...
+
+    @abstractmethod
+    def _get_node(
+        self,
+        key: Any,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Union[Optional[Node], List[Optional[Node]]]:
+        ...
+
+    @abstractmethod
+    def __delitem__(self, key: Any) -> None:
+        ...
+
+    @abstractmethod
+    def __setitem__(self, key: Any, value: Any) -> None:
+        ...
+
+    @abstractmethod
+    def __iter__(self) -> Iterator[Any]:
+        ...
+
+    @abstractmethod
+    def __getitem__(self, key_or_index: Any) -> Any:
+        ...
+
+    def _resolve_key_and_root(self, key: str) -> Tuple["Container", str]:
+        orig = key
+        if not key.startswith("."):
+            return self._get_root(), key
+        else:
+            root: Optional[Container] = self
+            assert key.startswith(".")
+            while True:
+                assert root is not None
+                key = key[1:]
+                if not key.startswith("."):
+                    break
+                root = root._get_parent_container()
+                if root is None:
+                    raise ConfigKeyError(f"Error resolving key '{orig}'")
+
+            return root, key
+
+    def _select_impl(
+        self,
+        key: str,
+        throw_on_missing: bool,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]] = None,
+    ) -> Tuple[Optional["Container"], Optional[str], Optional[Node]]:
+        """
+        Select a value using dot separated key sequence
+        """
+        from .omegaconf import _select_one
+
+        if key == "":
+            return self, "", self
+
+        split = split_key(key)
+        root: Optional[Container] = self
+        for i in range(len(split) - 1):
+            if root is None:
+                break
+
+            k = split[i]
+            ret, _ = _select_one(
+                c=root,
+                key=k,
+                throw_on_missing=throw_on_missing,
+                throw_on_type_error=throw_on_resolution_failure,
+            )
+            if isinstance(ret, Node):
+                ret = ret._maybe_dereference_node(
+                    throw_on_resolution_failure=throw_on_resolution_failure,
+                    memo=memo,
+                )
+
+            if ret is not None and not isinstance(ret, Container):
+                parent_key = ".".join(split[0 : i + 1])
+                child_key = split[i + 1]
+                raise ConfigTypeError(
+                    f"Error trying to access {key}: node `{parent_key}` "
+                    f"is not a container and thus cannot contain `{child_key}`"
+                )
+            root = ret
+
+        if root is None:
+            return None, None, None
+
+        last_key = split[-1]
+        value, _ = _select_one(
+            c=root,
+            key=last_key,
+            throw_on_missing=throw_on_missing,
+            throw_on_type_error=throw_on_resolution_failure,
+        )
+        if value is None:
+            return root, last_key, None
+
+        if memo is not None:
+            vid = id(value)
+            if vid in memo:
+                raise InterpolationResolutionError("Recursive interpolation detected")
+            # push to memo "stack"
+            memo.add(vid)
+
+        try:
+            value = root._maybe_resolve_interpolation(
+                parent=root,
+                key=last_key,
+                value=value,
+                throw_on_resolution_failure=throw_on_resolution_failure,
+                memo=memo,
+            )
+        finally:
+            if memo is not None:
+                # pop from memo "stack"
+                memo.remove(vid)
+
+        return root, last_key, value
+
+    def _resolve_interpolation_from_parse_tree(
+        self,
+        parent: Optional["Container"],
+        value: "Node",
+        key: Any,
+        parse_tree: OmegaConfGrammarParser.ConfigValueContext,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]],
+    ) -> Optional["Node"]:
+        """
+        Resolve an interpolation.
+
+        This happens in two steps:
+            1. The parse tree is visited, which outputs either a `Node` (e.g.,
+               for node interpolations "${foo}"), a string (e.g., for string
+               interpolations "hello ${name}", or any other arbitrary value
+               (e.g., or custom interpolations "${foo:bar}").
+            2. This output is potentially validated and converted when the node
+               being resolved (`value`) is typed.
+
+        If an error occurs in one of the above steps, an `InterpolationResolutionError`
+        (or a subclass of it) is raised, *unless* `throw_on_resolution_failure` is set
+        to `False` (in which case the return value is `None`).
+
+        :param parent: Parent of the node being resolved.
+        :param value: Node being resolved.
+        :param key: The associated key in the parent.
+        :param parse_tree: The parse tree as obtained from `grammar_parser.parse()`.
+        :param throw_on_resolution_failure: If `False`, then exceptions raised during
+            the resolution of the interpolation are silenced, and instead `None` is
+            returned.
+
+        :return: A `Node` that contains the interpolation result. This may be an existing
+            node in the config (in the case of a node interpolation "${foo}"), or a new
+            node that is created to wrap the interpolated value. It is `None` if and only if
+            `throw_on_resolution_failure` is `False` and an error occurs during resolution.
+        """
+
+        try:
+            resolved = self.resolve_parse_tree(
+                parse_tree=parse_tree, node=value, key=key, memo=memo
+            )
+        except InterpolationResolutionError:
+            if throw_on_resolution_failure:
+                raise
+            return None
+
+        return self._validate_and_convert_interpolation_result(
+            parent=parent,
+            value=value,
+            key=key,
+            resolved=resolved,
+            throw_on_resolution_failure=throw_on_resolution_failure,
+        )
+
+    def _validate_and_convert_interpolation_result(
+        self,
+        parent: Optional["Container"],
+        value: "Node",
+        key: Any,
+        resolved: Any,
+        throw_on_resolution_failure: bool,
+    ) -> Optional["Node"]:
+        from .nodes import AnyNode, InterpolationResultNode, ValueNode
+
+        # If the output is not a Node already (e.g., because it is the output of a
+        # custom resolver), then we will need to wrap it within a Node.
+        must_wrap = not isinstance(resolved, Node)
+
+        # If the node is typed, validate (and possibly convert) the result.
+        if isinstance(value, ValueNode) and not isinstance(value, AnyNode):
+            res_value = _get_value(resolved)
+            try:
+                conv_value = value.validate_and_convert(res_value)
+            except ValidationError as e:
+                if throw_on_resolution_failure:
+                    self._format_and_raise(
+                        key=key,
+                        value=res_value,
+                        cause=e,
+                        msg=f"While dereferencing interpolation '{value}': {e}",
+                        type_override=InterpolationValidationError,
+                    )
+                return None
+
+            # If the converted value is of the same type, it means that no conversion
+            # was actually needed. As a result, we can keep the original `resolved`
+            # (and otherwise, the converted value must be wrapped into a new node).
+            if type(conv_value) != type(res_value):
+                must_wrap = True
+                resolved = conv_value
+
+        if must_wrap:
+            return InterpolationResultNode(value=resolved, key=key, parent=parent)
+        else:
+            assert isinstance(resolved, Node)
+            return resolved
+
+    def _validate_not_dereferencing_to_parent(self, node: Node, target: Node) -> None:
+        parent: Optional[Node] = node
+        while parent is not None:
+            if parent is target:
+                raise InterpolationResolutionError(
+                    "Interpolation to parent node detected"
+                )
+            parent = parent._get_parent()
+
+    def _resolve_node_interpolation(
+        self, inter_key: str, memo: Optional[Set[int]]
+    ) -> "Node":
+        """A node interpolation is of the form `${foo.bar}`"""
+        try:
+            root_node, inter_key = self._resolve_key_and_root(inter_key)
+        except ConfigKeyError as exc:
+            raise InterpolationKeyError(
+                f"ConfigKeyError while resolving interpolation: {exc}"
+            ).with_traceback(sys.exc_info()[2])
+
+        try:
+            parent, last_key, value = root_node._select_impl(
+                inter_key,
+                throw_on_missing=True,
+                throw_on_resolution_failure=True,
+                memo=memo,
+            )
+        except MissingMandatoryValue as exc:
+            raise InterpolationToMissingValueError(
+                f"MissingMandatoryValue while resolving interpolation: {exc}"
+            ).with_traceback(sys.exc_info()[2])
+
+        if parent is None or value is None:
+            raise InterpolationKeyError(f"Interpolation key '{inter_key}' not found")
+        else:
+            self._validate_not_dereferencing_to_parent(node=self, target=value)
+            return value
+
+    def _evaluate_custom_resolver(
+        self,
+        key: Any,
+        node: Node,
+        inter_type: str,
+        inter_args: Tuple[Any, ...],
+        inter_args_str: Tuple[str, ...],
+    ) -> Any:
+        from omegaconf import OmegaConf
+
+        resolver = OmegaConf._get_resolver(inter_type)
+        if resolver is not None:
+            root_node = self._get_root()
+            return resolver(
+                root_node,
+                self,
+                node,
+                inter_args,
+                inter_args_str,
+            )
+        else:
+            raise UnsupportedInterpolationType(
+                f"Unsupported interpolation type {inter_type}"
+            )
+
+    def _maybe_resolve_interpolation(
+        self,
+        parent: Optional["Container"],
+        key: Any,
+        value: Node,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]] = None,
+    ) -> Optional[Node]:
+        value_kind = get_value_kind(value)
+        if value_kind != ValueKind.INTERPOLATION:
+            return value
+
+        parse_tree = parse(_get_value(value))
+        return self._resolve_interpolation_from_parse_tree(
+            parent=parent,
+            value=value,
+            key=key,
+            parse_tree=parse_tree,
+            throw_on_resolution_failure=throw_on_resolution_failure,
+            memo=memo if memo is not None else set(),
+        )
+
+    def resolve_parse_tree(
+        self,
+        parse_tree: ParserRuleContext,
+        node: Node,
+        memo: Optional[Set[int]] = None,
+        key: Optional[Any] = None,
+    ) -> Any:
+        """
+        Resolve a given parse tree into its value.
+
+        We make no assumption here on the type of the tree's root, so that the
+        return value may be of any type.
+        """
+
+        def node_interpolation_callback(
+            inter_key: str, memo: Optional[Set[int]]
+        ) -> Optional["Node"]:
+            return self._resolve_node_interpolation(inter_key=inter_key, memo=memo)
+
+        def resolver_interpolation_callback(
+            name: str, args: Tuple[Any, ...], args_str: Tuple[str, ...]
+        ) -> Any:
+            return self._evaluate_custom_resolver(
+                key=key,
+                node=node,
+                inter_type=name,
+                inter_args=args,
+                inter_args_str=args_str,
+            )
+
+        visitor = GrammarVisitor(
+            node_interpolation_callback=node_interpolation_callback,
+            resolver_interpolation_callback=resolver_interpolation_callback,
+            memo=memo,
+        )
+        try:
+            return visitor.visit(parse_tree)
+        except InterpolationResolutionError:
+            raise
+        except Exception as exc:
+            # Other kinds of exceptions are wrapped in an `InterpolationResolutionError`.
+            raise InterpolationResolutionError(
+                f"{type(exc).__name__} raised while resolving interpolation: {exc}"
+            ).with_traceback(sys.exc_info()[2])
+
+    def _invalidate_flags_cache(self) -> None:
+        from .dictconfig import DictConfig
+        from .listconfig import ListConfig
+
+        # invalidate subtree cache only if the cache is initialized in this node.
+
+        if self.__dict__["_flags_cache"] is not None:
+            self.__dict__["_flags_cache"] = None
+            if isinstance(self, DictConfig):
+                content = self.__dict__["_content"]
+                if isinstance(content, dict):
+                    for value in self.__dict__["_content"].values():
+                        value._invalidate_flags_cache()
+            elif isinstance(self, ListConfig):
+                content = self.__dict__["_content"]
+                if isinstance(content, list):
+                    for item in self.__dict__["_content"]:
+                        item._invalidate_flags_cache()
+
+
+class SCMode(Enum):
+    DICT = 1  # Convert to plain dict
+    DICT_CONFIG = 2  # Keep as OmegaConf DictConfig
+    INSTANTIATE = 3  # Create a dataclass or attrs class instance
+
+
+class UnionNode(Box):
+    """
+    This class handles Union type hints. The `_content` attribute is either a
+    child node that is compatible with the given Union ref_type, or it is a
+    special value (None or MISSING or interpolation).
+
+    Much of the logic for e.g. value assignment and type validation is
+    delegated to the child node. As such, UnionNode functions as a
+    "pass-through" node. User apps and downstream libraries should not need to
+    know about UnionNode (assuming they only use OmegaConf's public API).
+    """
+
+    _parent: Optional[Container]
+    _content: Union[Node, None, str]
+
+    def __init__(
+        self,
+        content: Any,
+        ref_type: Any,
+        is_optional: bool = True,
+        key: Any = None,
+        parent: Optional[Box] = None,
+    ) -> None:
+        try:
+            if not is_union_annotation(ref_type):  # pragma: no cover
+                msg = (
+                    f"UnionNode got unexpected ref_type {ref_type}. Please file a bug"
+                    + " report at https://github.com/omry/omegaconf/issues"
+                )
+                raise AssertionError(msg)
+            if not isinstance(parent, (Container, NoneType)):
+                raise ConfigTypeError("Parent type is not omegaconf.Container")
+            super().__init__(
+                parent=parent,
+                metadata=Metadata(
+                    ref_type=ref_type,
+                    object_type=None,
+                    optional=is_optional,
+                    key=key,
+                    flags={"convert": False},
+                ),
+            )
+            self._set_value(content)
+        except Exception as ex:
+            format_and_raise(node=None, key=key, value=content, msg=str(ex), cause=ex)
+
+    def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str:
+        parent = self._get_parent()
+        if parent is None:
+            if self._metadata.key is None:
+                return ""
+            else:
+                return str(self._metadata.key)
+        else:
+            return parent._get_full_key(self._metadata.key)
+
+    def __eq__(self, other: Any) -> bool:
+        content = self.__dict__["_content"]
+        if isinstance(content, Node):
+            ret = content.__eq__(other)
+        elif isinstance(other, Node):
+            ret = other.__eq__(content)
+        else:
+            ret = content.__eq__(other)
+        assert isinstance(ret, (bool, type(NotImplemented)))
+        return ret
+
+    def __ne__(self, other: Any) -> bool:
+        x = self.__eq__(other)
+        if x is NotImplemented:
+            return NotImplemented
+        return not x
+
+    def __hash__(self) -> int:
+        return hash(self.__dict__["_content"])
+
+    def _value(self) -> Union[Node, None, str]:
+        content = self.__dict__["_content"]
+        assert isinstance(content, (Node, NoneType, str))
+        return content
+
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        previous_content = self.__dict__["_content"]
+        previous_metadata = self.__dict__["_metadata"]
+        try:
+            self._set_value_impl(value, flags)
+        except Exception as e:
+            self.__dict__["_content"] = previous_content
+            self.__dict__["_metadata"] = previous_metadata
+            raise e
+
+    def _set_value_impl(
+        self, value: Any, flags: Optional[Dict[str, bool]] = None
+    ) -> None:
+        from omegaconf.omegaconf import _node_wrap
+
+        ref_type = self._metadata.ref_type
+        type_hint = self._metadata.type_hint
+
+        value = _get_value(value)
+        if _is_special(value):
+            assert isinstance(value, (str, NoneType))
+            if value is None:
+                if not self._is_optional():
+                    raise ValidationError(
+                        f"Value '$VALUE' is incompatible with type hint '{type_str(type_hint)}'"
+                    )
+            self.__dict__["_content"] = value
+        elif isinstance(value, Container):
+            raise ValidationError(
+                f"Cannot assign container '$VALUE' of type '$VALUE_TYPE' to {type_str(type_hint)}"
+            )
+        else:
+            for candidate_ref_type in ref_type.__args__:
+                try:
+                    self.__dict__["_content"] = _node_wrap(
+                        value=value,
+                        ref_type=candidate_ref_type,
+                        is_optional=False,
+                        key=None,
+                        parent=self,
+                    )
+                    break
+                except ValidationError:
+                    continue
+            else:
+                raise ValidationError(
+                    f"Value '$VALUE' of type '$VALUE_TYPE' is incompatible with type hint '{type_str(type_hint)}'"
+                )
+
+    def _is_optional(self) -> bool:
+        return self.__dict__["_metadata"].optional is True
+
+    def _is_interpolation(self) -> bool:
+        return _is_interpolation(self.__dict__["_content"])
+
+    def __str__(self) -> str:
+        return str(self.__dict__["_content"])
+
+    def __repr__(self) -> str:
+        return repr(self.__dict__["_content"])
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "UnionNode":
+        res = object.__new__(type(self))
+        for key, value in self.__dict__.items():
+            if key not in ("_content", "_parent"):
+                res.__dict__[key] = copy.deepcopy(value, memo=memo)
+
+        src_content = self.__dict__["_content"]
+        if isinstance(src_content, Node):
+            old_parent = src_content.__dict__["_parent"]
+            try:
+                src_content.__dict__["_parent"] = None
+                content_copy = copy.deepcopy(src_content, memo=memo)
+                content_copy.__dict__["_parent"] = res
+            finally:
+                src_content.__dict__["_parent"] = old_parent
+        else:
+            # None and strings can be assigned as is
+            content_copy = src_content
+
+        res.__dict__["_content"] = content_copy
+        res.__dict__["_parent"] = self.__dict__["_parent"]
+        return res

lib/python3.12/site-packages/omegaconf/basecontainer.py

@@ -0,0 +1,916 @@
+import copy
+import sys
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Tuple, Union
+
+import yaml
+
+from ._utils import (
+    _DEFAULT_MARKER_,
+    ValueKind,
+    _ensure_container,
+    _get_value,
+    _is_interpolation,
+    _is_missing_value,
+    _is_none,
+    _is_special,
+    _resolve_optional,
+    get_structured_config_data,
+    get_type_hint,
+    get_value_kind,
+    get_yaml_loader,
+    is_container_annotation,
+    is_dict_annotation,
+    is_list_annotation,
+    is_primitive_dict,
+    is_primitive_type_annotation,
+    is_structured_config,
+    is_tuple_annotation,
+    is_union_annotation,
+)
+from .base import (
+    Box,
+    Container,
+    ContainerMetadata,
+    DictKeyType,
+    Node,
+    SCMode,
+    UnionNode,
+)
+from .errors import (
+    ConfigCycleDetectedException,
+    ConfigTypeError,
+    InterpolationResolutionError,
+    KeyValidationError,
+    MissingMandatoryValue,
+    OmegaConfBaseException,
+    ReadonlyConfigError,
+    ValidationError,
+)
+
+if TYPE_CHECKING:
+    from .dictconfig import DictConfig  # pragma: no cover
+
+
+class BaseContainer(Container, ABC):
+    _resolvers: ClassVar[Dict[str, Any]] = {}
+
+    def __init__(self, parent: Optional[Box], metadata: ContainerMetadata):
+        if not (parent is None or isinstance(parent, Box)):
+            raise ConfigTypeError("Parent type is not omegaconf.Box")
+        super().__init__(parent=parent, metadata=metadata)
+
+    def _get_child(
+        self,
+        key: Any,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Union[Optional[Node], List[Optional[Node]]]:
+        """Like _get_node, passing through to the nearest concrete Node."""
+        child = self._get_node(
+            key=key,
+            validate_access=validate_access,
+            validate_key=validate_key,
+            throw_on_missing_value=throw_on_missing_value,
+            throw_on_missing_key=throw_on_missing_key,
+        )
+        if isinstance(child, UnionNode) and not _is_special(child):
+            value = child._value()
+            assert isinstance(value, Node) and not isinstance(value, UnionNode)
+            child = value
+        return child
+
+    def _resolve_with_default(
+        self,
+        key: Union[DictKeyType, int],
+        value: Node,
+        default_value: Any = _DEFAULT_MARKER_,
+    ) -> Any:
+        """returns the value with the specified key, like obj.key and obj['key']"""
+        if _is_missing_value(value):
+            if default_value is not _DEFAULT_MARKER_:
+                return default_value
+            raise MissingMandatoryValue("Missing mandatory value: $FULL_KEY")
+
+        resolved_node = self._maybe_resolve_interpolation(
+            parent=self,
+            key=key,
+            value=value,
+            throw_on_resolution_failure=True,
+        )
+
+        return _get_value(resolved_node)
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __repr__(self) -> str:
+        if self.__dict__["_content"] is None:
+            return "None"
+        elif self._is_interpolation() or self._is_missing():
+            v = self.__dict__["_content"]
+            return f"'{v}'"
+        else:
+            return self.__dict__["_content"].__repr__()  # type: ignore
+
+    # Support pickle
+    def __getstate__(self) -> Dict[str, Any]:
+        dict_copy = copy.copy(self.__dict__)
+
+        # no need to serialize the flags cache, it can be re-constructed later
+        dict_copy.pop("_flags_cache", None)
+
+        dict_copy["_metadata"] = copy.copy(dict_copy["_metadata"])
+        ref_type = self._metadata.ref_type
+        if is_container_annotation(ref_type):
+            if is_dict_annotation(ref_type):
+                dict_copy["_metadata"].ref_type = Dict
+            elif is_list_annotation(ref_type):
+                dict_copy["_metadata"].ref_type = List
+            else:
+                assert False
+        if sys.version_info < (3, 7):  # pragma: no cover
+            element_type = self._metadata.element_type
+            if is_union_annotation(element_type):
+                raise OmegaConfBaseException(
+                    "Serializing structured configs with `Union` element type requires python >= 3.7"
+                )
+        return dict_copy
+
+    # Support pickle
+    def __setstate__(self, d: Dict[str, Any]) -> None:
+        from omegaconf import DictConfig
+        from omegaconf._utils import is_generic_dict, is_generic_list
+
+        if isinstance(self, DictConfig):
+            key_type = d["_metadata"].key_type
+
+            # backward compatibility to load OmegaConf 2.0 configs
+            if key_type is None:
+                key_type = Any
+                d["_metadata"].key_type = key_type
+
+        element_type = d["_metadata"].element_type
+
+        # backward compatibility to load OmegaConf 2.0 configs
+        if element_type is None:
+            element_type = Any
+            d["_metadata"].element_type = element_type
+
+        ref_type = d["_metadata"].ref_type
+        if is_container_annotation(ref_type):
+            if is_generic_dict(ref_type):
+                d["_metadata"].ref_type = Dict[key_type, element_type]  # type: ignore
+            elif is_generic_list(ref_type):
+                d["_metadata"].ref_type = List[element_type]  # type: ignore
+            else:
+                assert False
+
+        d["_flags_cache"] = None
+        self.__dict__.update(d)
+
+    @abstractmethod
+    def __delitem__(self, key: Any) -> None:
+        ...
+
+    def __len__(self) -> int:
+        if self._is_none() or self._is_missing() or self._is_interpolation():
+            return 0
+        content = self.__dict__["_content"]
+        return len(content)
+
+    def merge_with_cli(self) -> None:
+        args_list = sys.argv[1:]
+        self.merge_with_dotlist(args_list)
+
+    def merge_with_dotlist(self, dotlist: List[str]) -> None:
+        from omegaconf import OmegaConf
+
+        def fail() -> None:
+            raise ValueError("Input list must be a list or a tuple of strings")
+
+        if not isinstance(dotlist, (list, tuple)):
+            fail()
+
+        for arg in dotlist:
+            if not isinstance(arg, str):
+                fail()
+
+            idx = arg.find("=")
+            if idx == -1:
+                key = arg
+                value = None
+            else:
+                key = arg[0:idx]
+                value = arg[idx + 1 :]
+                value = yaml.load(value, Loader=get_yaml_loader())
+
+            OmegaConf.update(self, key, value)
+
+    def is_empty(self) -> bool:
+        """return true if config is empty"""
+        return len(self.__dict__["_content"]) == 0
+
+    @staticmethod
+    def _to_content(
+        conf: Container,
+        resolve: bool,
+        throw_on_missing: bool,
+        enum_to_str: bool = False,
+        structured_config_mode: SCMode = SCMode.DICT,
+    ) -> Union[None, Any, str, Dict[DictKeyType, Any], List[Any]]:
+        from omegaconf import MISSING, DictConfig, ListConfig
+
+        def convert(val: Node) -> Any:
+            value = val._value()
+            if enum_to_str and isinstance(value, Enum):
+                value = f"{value.name}"
+
+            return value
+
+        def get_node_value(key: Union[DictKeyType, int]) -> Any:
+            try:
+                node = conf._get_child(key, throw_on_missing_value=throw_on_missing)
+            except MissingMandatoryValue as e:
+                conf._format_and_raise(key=key, value=None, cause=e)
+            assert isinstance(node, Node)
+            if resolve:
+                try:
+                    node = node._dereference_node()
+                except InterpolationResolutionError as e:
+                    conf._format_and_raise(key=key, value=None, cause=e)
+
+            if isinstance(node, Container):
+                value = BaseContainer._to_content(
+                    node,
+                    resolve=resolve,
+                    throw_on_missing=throw_on_missing,
+                    enum_to_str=enum_to_str,
+                    structured_config_mode=structured_config_mode,
+                )
+            else:
+                value = convert(node)
+            return value
+
+        if conf._is_none():
+            return None
+        elif conf._is_missing():
+            if throw_on_missing:
+                conf._format_and_raise(
+                    key=None,
+                    value=None,
+                    cause=MissingMandatoryValue("Missing mandatory value"),
+                )
+            else:
+                return MISSING
+        elif not resolve and conf._is_interpolation():
+            inter = conf._value()
+            assert isinstance(inter, str)
+            return inter
+
+        if resolve:
+            _conf = conf._dereference_node()
+            assert isinstance(_conf, Container)
+            conf = _conf
+
+        if isinstance(conf, DictConfig):
+            if (
+                conf._metadata.object_type not in (dict, None)
+                and structured_config_mode == SCMode.DICT_CONFIG
+            ):
+                return conf
+            if structured_config_mode == SCMode.INSTANTIATE and is_structured_config(
+                conf._metadata.object_type
+            ):
+                return conf._to_object()
+
+            retdict: Dict[DictKeyType, Any] = {}
+            for key in conf.keys():
+                value = get_node_value(key)
+                if enum_to_str and isinstance(key, Enum):
+                    key = f"{key.name}"
+                retdict[key] = value
+            return retdict
+        elif isinstance(conf, ListConfig):
+            retlist: List[Any] = []
+            for index in range(len(conf)):
+                item = get_node_value(index)
+                retlist.append(item)
+
+            return retlist
+        assert False
+
+    @staticmethod
+    def _map_merge(dest: "BaseContainer", src: "BaseContainer") -> None:
+        """merge src into dest and return a new copy, does not modified input"""
+        from omegaconf import AnyNode, DictConfig, ValueNode
+
+        assert isinstance(dest, DictConfig)
+        assert isinstance(src, DictConfig)
+        src_type = src._metadata.object_type
+        src_ref_type = get_type_hint(src)
+        assert src_ref_type is not None
+
+        # If source DictConfig is:
+        #  - None => set the destination DictConfig to None
+        #  - an interpolation => set the destination DictConfig to be the same interpolation
+        if src._is_none() or src._is_interpolation():
+            dest._set_value(src._value())
+            _update_types(node=dest, ref_type=src_ref_type, object_type=src_type)
+            return
+
+        dest._validate_merge(value=src)
+
+        def expand(node: Container) -> None:
+            rt = node._metadata.ref_type
+            val: Any
+            if rt is not Any:
+                if is_dict_annotation(rt):
+                    val = {}
+                elif is_list_annotation(rt) or is_tuple_annotation(rt):
+                    val = []
+                else:
+                    val = rt
+            elif isinstance(node, DictConfig):
+                val = {}
+            else:
+                assert False
+
+            node._set_value(val)
+
+        if (
+            src._is_missing()
+            and not dest._is_missing()
+            and is_structured_config(src_ref_type)
+        ):
+            # Replace `src` with a prototype of its corresponding structured config
+            # whose fields are all missing (to avoid overwriting fields in `dest`).
+            assert src_type is None  # src missing, so src's object_type should be None
+            src_type = src_ref_type
+            src = _create_structured_with_missing_fields(
+                ref_type=src_ref_type, object_type=src_type
+            )
+
+        if (dest._is_interpolation() or dest._is_missing()) and not src._is_missing():
+            expand(dest)
+
+        src_items = list(src) if not src._is_missing() else []
+        for key in src_items:
+            src_node = src._get_node(key, validate_access=False)
+            dest_node = dest._get_node(key, validate_access=False)
+            assert isinstance(src_node, Node)
+            assert dest_node is None or isinstance(dest_node, Node)
+            src_value = _get_value(src_node)
+
+            src_vk = get_value_kind(src_node)
+            src_node_missing = src_vk is ValueKind.MANDATORY_MISSING
+
+            if isinstance(dest_node, DictConfig):
+                dest_node._validate_merge(value=src_node)
+
+            if (
+                isinstance(dest_node, Container)
+                and dest_node._is_none()
+                and not src_node_missing
+                and not _is_none(src_node, resolve=True)
+            ):
+                expand(dest_node)
+
+            if dest_node is not None and dest_node._is_interpolation():
+                target_node = dest_node._maybe_dereference_node()
+                if isinstance(target_node, Container):
+                    dest[key] = target_node
+                    dest_node = dest._get_node(key)
+
+            is_optional, et = _resolve_optional(dest._metadata.element_type)
+            if dest_node is None and is_structured_config(et) and not src_node_missing:
+                # merging into a new node. Use element_type as a base
+                dest[key] = DictConfig(
+                    et, parent=dest, ref_type=et, is_optional=is_optional
+                )
+                dest_node = dest._get_node(key)
+
+            if dest_node is not None:
+                if isinstance(dest_node, BaseContainer):
+                    if isinstance(src_node, BaseContainer):
+                        dest_node._merge_with(src_node)
+                    elif not src_node_missing:
+                        dest.__setitem__(key, src_node)
+                else:
+                    if isinstance(src_node, BaseContainer):
+                        dest.__setitem__(key, src_node)
+                    else:
+                        assert isinstance(dest_node, (ValueNode, UnionNode))
+                        assert isinstance(src_node, (ValueNode, UnionNode))
+                        try:
+                            if isinstance(dest_node, AnyNode):
+                                if src_node_missing:
+                                    node = copy.copy(src_node)
+                                    # if src node is missing, use the value from the dest_node,
+                                    # but validate it against the type of the src node before assigment
+                                    node._set_value(dest_node._value())
+                                else:
+                                    node = src_node
+                                dest.__setitem__(key, node)
+                            else:
+                                if not src_node_missing:
+                                    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_merge
+                    with open_dict(dest):
+                        dest[key] = src._get_node(key)
+                else:
+                    dest[key] = src._get_node(key)
+
+        _update_types(node=dest, ref_type=src_ref_type, object_type=src_type)
+
+        # explicit flags on the source config are replacing the flag values in the destination
+        flags = src._metadata.flags
+        assert flags is not None
+        for flag, value in flags.items():
+            if value is not None:
+                dest._set_flag(flag, value)
+
+    @staticmethod
+    def _list_merge(dest: Any, src: Any) -> None:
+        from omegaconf import DictConfig, ListConfig, OmegaConf
+
+        assert isinstance(dest, ListConfig)
+        assert isinstance(src, ListConfig)
+
+        if src._is_none():
+            dest._set_value(None)
+        elif src._is_missing():
+            # do not change dest if src is MISSING.
+            if dest._metadata.element_type is Any:
+                dest._metadata.element_type = src._metadata.element_type
+        elif src._is_interpolation():
+            dest._set_value(src._value())
+        else:
+            temp_target = ListConfig(content=[], parent=dest._get_parent())
+            temp_target.__dict__["_metadata"] = copy.deepcopy(
+                dest.__dict__["_metadata"]
+            )
+            is_optional, et = _resolve_optional(dest._metadata.element_type)
+            if is_structured_config(et):
+                prototype = DictConfig(et, ref_type=et, is_optional=is_optional)
+                for item in src._iter_ex(resolve=False):
+                    if isinstance(item, DictConfig):
+                        item = OmegaConf.merge(prototype, item)
+                    temp_target.append(item)
+            else:
+                for item in src._iter_ex(resolve=False):
+                    temp_target.append(item)
+
+            dest.__dict__["_content"] = temp_target.__dict__["_content"]
+
+        # explicit flags on the source config are replacing the flag values in the destination
+        flags = src._metadata.flags
+        assert flags is not None
+        for flag, value in flags.items():
+            if value is not None:
+                dest._set_flag(flag, value)
+
+    def merge_with(
+        self,
+        *others: Union[
+            "BaseContainer", Dict[str, Any], List[Any], Tuple[Any, ...], Any
+        ],
+    ) -> None:
+        try:
+            self._merge_with(*others)
+        except Exception as e:
+            self._format_and_raise(key=None, value=None, cause=e)
+
+    def _merge_with(
+        self,
+        *others: Union[
+            "BaseContainer", Dict[str, Any], List[Any], Tuple[Any, ...], Any
+        ],
+    ) -> None:
+        from .dictconfig import DictConfig
+        from .listconfig import ListConfig
+
+        """merge a list of other Config objects into this one, overriding as needed"""
+        for other in others:
+            if other is None:
+                raise ValueError("Cannot merge with a None config")
+
+            my_flags = {}
+            if self._get_flag("allow_objects") is True:
+                my_flags = {"allow_objects": True}
+            other = _ensure_container(other, flags=my_flags)
+
+            if isinstance(self, DictConfig) and isinstance(other, DictConfig):
+                BaseContainer._map_merge(self, other)
+            elif isinstance(self, ListConfig) and isinstance(other, ListConfig):
+                BaseContainer._list_merge(self, other)
+            else:
+                raise TypeError("Cannot merge DictConfig with ListConfig")
+
+        # recursively correct the parent hierarchy after the merge
+        self._re_parent()
+
+    # noinspection PyProtectedMember
+    def _set_item_impl(self, key: Any, value: Any) -> None:
+        """
+        Changes the value of the node key with the desired value. If the node key doesn't
+        exist it creates a new one.
+        """
+        from .nodes import AnyNode, ValueNode
+
+        if isinstance(value, Node):
+            do_deepcopy = not self._get_flag("no_deepcopy_set_nodes")
+            if not do_deepcopy and isinstance(value, Box):
+                # if value is from the same config, perform a deepcopy no matter what.
+                if self._get_root() is value._get_root():
+                    do_deepcopy = True
+
+            if do_deepcopy:
+                value = copy.deepcopy(value)
+            value._set_parent(None)
+
+            try:
+                old = value._key()
+                value._set_key(key)
+                self._validate_set(key, value)
+            finally:
+                value._set_key(old)
+        else:
+            self._validate_set(key, value)
+
+        if self._get_flag("readonly"):
+            raise ReadonlyConfigError("Cannot change read-only config container")
+
+        input_is_node = isinstance(value, Node)
+        target_node_ref = self._get_node(key)
+        assert target_node_ref is None or isinstance(target_node_ref, Node)
+
+        input_is_typed_vnode = isinstance(value, ValueNode) and not isinstance(
+            value, AnyNode
+        )
+
+        def get_target_type_hint(val: Any) -> Any:
+            if not is_structured_config(val):
+                type_hint = self._metadata.element_type
+            else:
+                target = self._get_node(key)
+                if target is None:
+                    type_hint = self._metadata.element_type
+                else:
+                    assert isinstance(target, Node)
+                    type_hint = target._metadata.type_hint
+            return type_hint
+
+        target_type_hint = get_target_type_hint(value)
+        _, target_ref_type = _resolve_optional(target_type_hint)
+
+        def assign(value_key: Any, val: Node) -> None:
+            assert val._get_parent() is None
+            v = val
+            v._set_parent(self)
+            v._set_key(value_key)
+            _deep_update_type_hint(node=v, type_hint=self._metadata.element_type)
+            self.__dict__["_content"][value_key] = v
+
+        if input_is_typed_vnode and not is_union_annotation(target_ref_type):
+            assign(key, value)
+        else:
+            # input is not a ValueNode, can be primitive or box
+
+            special_value = _is_special(value)
+            # We use the `Node._set_value` method if the target node exists and:
+            # 1. the target has an explicit ref_type, or
+            # 2. the target is an AnyNode and the input is a primitive type.
+            should_set_value = target_node_ref is not None and (
+                target_node_ref._has_ref_type()
+                or (
+                    isinstance(target_node_ref, AnyNode)
+                    and is_primitive_type_annotation(value)
+                )
+            )
+            if should_set_value:
+                if special_value and isinstance(value, Node):
+                    value = value._value()
+                self.__dict__["_content"][key]._set_value(value)
+            elif input_is_node:
+                if (
+                    special_value
+                    and (
+                        is_container_annotation(target_ref_type)
+                        or is_structured_config(target_ref_type)
+                    )
+                    or is_primitive_type_annotation(target_ref_type)
+                    or is_union_annotation(target_ref_type)
+                ):
+                    value = _get_value(value)
+                    self._wrap_value_and_set(key, value, target_type_hint)
+                else:
+                    assign(key, value)
+            else:
+                self._wrap_value_and_set(key, value, target_type_hint)
+
+    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
+
+    @staticmethod
+    def _item_eq(
+        c1: Container,
+        k1: Union[DictKeyType, int],
+        c2: Container,
+        k2: Union[DictKeyType, int],
+    ) -> bool:
+        v1 = c1._get_child(k1)
+        v2 = c2._get_child(k2)
+        assert v1 is not None and v2 is not None
+
+        assert isinstance(v1, Node)
+        assert isinstance(v2, Node)
+
+        if v1._is_none() and v2._is_none():
+            return True
+
+        if v1._is_missing() and v2._is_missing():
+            return True
+
+        v1_inter = v1._is_interpolation()
+        v2_inter = v2._is_interpolation()
+        dv1: Optional[Node] = v1
+        dv2: Optional[Node] = v2
+
+        if v1_inter:
+            dv1 = v1._maybe_dereference_node()
+        if v2_inter:
+            dv2 = v2._maybe_dereference_node()
+
+        if v1_inter and v2_inter:
+            if dv1 is None or dv2 is None:
+                return v1 == v2
+            else:
+                # both are not none, if both are containers compare as container
+                if isinstance(dv1, Container) and isinstance(dv2, Container):
+                    if dv1 != dv2:
+                        return False
+                dv1 = _get_value(dv1)
+                dv2 = _get_value(dv2)
+                return dv1 == dv2
+        elif not v1_inter and not v2_inter:
+            v1 = _get_value(v1)
+            v2 = _get_value(v2)
+            ret = v1 == v2
+            assert isinstance(ret, bool)
+            return ret
+        else:
+            dv1 = _get_value(dv1)
+            dv2 = _get_value(dv2)
+            ret = dv1 == dv2
+            assert isinstance(ret, bool)
+            return ret
+
+    def _is_optional(self) -> bool:
+        return self.__dict__["_metadata"].optional is True
+
+    def _is_interpolation(self) -> bool:
+        return _is_interpolation(self.__dict__["_content"])
+
+    @abstractmethod
+    def _validate_get(self, key: Any, value: Any = None) -> None:
+        ...
+
+    @abstractmethod
+    def _validate_set(self, key: Any, value: Any) -> None:
+        ...
+
+    def _value(self) -> Any:
+        return self.__dict__["_content"]
+
+    def _get_full_key(self, key: Union[DictKeyType, int, slice, None]) -> str:
+        from .listconfig import ListConfig
+        from .omegaconf import _select_one
+
+        if not isinstance(key, (int, str, Enum, float, bool, slice, bytes, type(None))):
+            return ""
+
+        def _slice_to_str(x: slice) -> str:
+            if x.step is not None:
+                return f"{x.start}:{x.stop}:{x.step}"
+            else:
+                return f"{x.start}:{x.stop}"
+
+        def prepand(
+            full_key: str,
+            parent_type: Any,
+            cur_type: Any,
+            key: Optional[Union[DictKeyType, int, slice]],
+        ) -> str:
+            if key is None:
+                return full_key
+
+            if isinstance(key, slice):
+                key = _slice_to_str(key)
+            elif isinstance(key, Enum):
+                key = key.name
+            else:
+                key = str(key)
+
+            assert isinstance(key, str)
+
+            if issubclass(parent_type, ListConfig):
+                if full_key != "":
+                    if issubclass(cur_type, ListConfig):
+                        full_key = f"[{key}]{full_key}"
+                    else:
+                        full_key = f"[{key}].{full_key}"
+                else:
+                    full_key = f"[{key}]"
+            else:
+                if full_key == "":
+                    full_key = key
+                else:
+                    if issubclass(cur_type, ListConfig):
+                        full_key = f"{key}{full_key}"
+                    else:
+                        full_key = f"{key}.{full_key}"
+            return full_key
+
+        if key is not None and key != "":
+            assert isinstance(self, Container)
+            cur, _ = _select_one(
+                c=self, key=str(key), throw_on_missing=False, throw_on_type_error=False
+            )
+            if cur is None:
+                cur = self
+                full_key = prepand("", type(cur), None, key)
+                if cur._key() is not None:
+                    full_key = prepand(
+                        full_key, type(cur._get_parent()), type(cur), cur._key()
+                    )
+            else:
+                full_key = prepand("", type(cur._get_parent()), type(cur), cur._key())
+        else:
+            cur = self
+            if cur._key() is None:
+                return ""
+            full_key = self._key()
+
+        assert cur is not None
+        memo = {id(cur)}  # remember already visited nodes so as to detect cycles
+        while cur._get_parent() is not None:
+            cur = cur._get_parent()
+            if id(cur) in memo:
+                raise ConfigCycleDetectedException(
+                    f"Cycle when iterating over parents of key `{key!s}`"
+                )
+            memo.add(id(cur))
+            assert cur is not None
+            if cur._key() is not None:
+                full_key = prepand(
+                    full_key, type(cur._get_parent()), type(cur), cur._key()
+                )
+
+        return full_key
+
+
+def _create_structured_with_missing_fields(
+    ref_type: type, object_type: Optional[type] = None
+) -> "DictConfig":
+    from . import MISSING, DictConfig
+
+    cfg_data = get_structured_config_data(ref_type)
+    for v in cfg_data.values():
+        v._set_value(MISSING)
+
+    cfg = DictConfig(cfg_data)
+    cfg._metadata.optional, cfg._metadata.ref_type = _resolve_optional(ref_type)
+    cfg._metadata.object_type = object_type
+
+    return cfg
+
+
+def _update_types(node: Node, ref_type: Any, object_type: Optional[type]) -> None:
+    if object_type is not None and not is_primitive_dict(object_type):
+        node._metadata.object_type = object_type
+
+    if node._metadata.ref_type is Any:
+        _deep_update_type_hint(node, ref_type)
+
+
+def _deep_update_type_hint(node: Node, type_hint: Any) -> None:
+    """Ensure node is compatible with type_hint, mutating if necessary."""
+    from omegaconf import DictConfig, ListConfig
+
+    from ._utils import get_dict_key_value_types, get_list_element_type
+
+    if type_hint is Any:
+        return
+
+    _shallow_validate_type_hint(node, type_hint)
+
+    new_is_optional, new_ref_type = _resolve_optional(type_hint)
+    node._metadata.ref_type = new_ref_type
+    node._metadata.optional = new_is_optional
+
+    if is_list_annotation(new_ref_type) and isinstance(node, ListConfig):
+        new_element_type = get_list_element_type(new_ref_type)
+        node._metadata.element_type = new_element_type
+        if not _is_special(node):
+            for i in range(len(node)):
+                _deep_update_subnode(node, i, new_element_type)
+
+    if is_dict_annotation(new_ref_type) and isinstance(node, DictConfig):
+        new_key_type, new_element_type = get_dict_key_value_types(new_ref_type)
+        node._metadata.key_type = new_key_type
+        node._metadata.element_type = new_element_type
+        if not _is_special(node):
+            for key in node:
+                if new_key_type is not Any and not isinstance(key, new_key_type):
+                    raise KeyValidationError(
+                        f"Key {key!r} ({type(key).__name__}) is incompatible"
+                        + f" with key type hint '{new_key_type.__name__}'"
+                    )
+                _deep_update_subnode(node, key, new_element_type)
+
+
+def _deep_update_subnode(node: BaseContainer, key: Any, value_type_hint: Any) -> None:
+    """Get node[key] and ensure it is compatible with value_type_hint, mutating if necessary."""
+    subnode = node._get_node(key)
+    assert isinstance(subnode, Node)
+    if _is_special(subnode):
+        # Ensure special values are wrapped in a Node subclass that
+        # is compatible with the type hint.
+        node._wrap_value_and_set(key, subnode._value(), value_type_hint)
+        subnode = node._get_node(key)
+        assert isinstance(subnode, Node)
+    _deep_update_type_hint(subnode, value_type_hint)
+
+
+def _shallow_validate_type_hint(node: Node, type_hint: Any) -> None:
+    """Error if node's type, content and metadata are not compatible with type_hint."""
+    from omegaconf import DictConfig, ListConfig, ValueNode
+
+    is_optional, ref_type = _resolve_optional(type_hint)
+
+    vk = get_value_kind(node)
+
+    if node._is_none():
+        if not is_optional:
+            value = _get_value(node)
+            raise ValidationError(
+                f"Value {value!r} ({type(value).__name__})"
+                + f" is incompatible with type hint '{ref_type.__name__}'"
+            )
+        return
+    elif vk in (ValueKind.MANDATORY_MISSING, ValueKind.INTERPOLATION):
+        return
+    elif vk == ValueKind.VALUE:
+        if is_primitive_type_annotation(ref_type) and isinstance(node, ValueNode):
+            value = node._value()
+            if not isinstance(value, ref_type):
+                raise ValidationError(
+                    f"Value {value!r} ({type(value).__name__})"
+                    + f" is incompatible with type hint '{ref_type.__name__}'"
+                )
+        elif is_structured_config(ref_type) and isinstance(node, DictConfig):
+            return
+        elif is_dict_annotation(ref_type) and isinstance(node, DictConfig):
+            return
+        elif is_list_annotation(ref_type) and isinstance(node, ListConfig):
+            return
+        else:
+            if isinstance(node, ValueNode):
+                value = node._value()
+                raise ValidationError(
+                    f"Value {value!r} ({type(value).__name__})"
+                    + f" is incompatible with type hint '{ref_type}'"
+                )
+            else:
+                raise ValidationError(
+                    f"'{type(node).__name__}' is incompatible"
+                    + f" with type hint '{ref_type}'"
+                )
+
+    else:
+        assert False

lib/python3.12/site-packages/omegaconf/dictconfig.py

@@ -0,0 +1,776 @@
+import copy
+from enum import Enum
+from typing import (
+    Any,
+    Dict,
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    List,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
+
+from ._utils import (
+    _DEFAULT_MARKER_,
+    ValueKind,
+    _get_value,
+    _is_interpolation,
+    _is_missing_literal,
+    _is_missing_value,
+    _is_none,
+    _resolve_optional,
+    _valid_dict_key_annotation_type,
+    format_and_raise,
+    get_structured_config_data,
+    get_structured_config_init_field_names,
+    get_type_of,
+    get_value_kind,
+    is_container_annotation,
+    is_dict,
+    is_primitive_dict,
+    is_structured_config,
+    is_structured_config_frozen,
+    type_str,
+)
+from .base import Box, Container, ContainerMetadata, DictKeyType, Node
+from .basecontainer import BaseContainer
+from .errors import (
+    ConfigAttributeError,
+    ConfigKeyError,
+    ConfigTypeError,
+    InterpolationResolutionError,
+    KeyValidationError,
+    MissingMandatoryValue,
+    OmegaConfBaseException,
+    ReadonlyConfigError,
+    ValidationError,
+)
+from .nodes import EnumNode, ValueNode
+
+
+class DictConfig(BaseContainer, MutableMapping[Any, Any]):
+
+    _metadata: ContainerMetadata
+    _content: Union[Dict[DictKeyType, Node], None, str]
+
+    def __init__(
+        self,
+        content: Union[Dict[DictKeyType, Any], "DictConfig", Any],
+        key: Any = None,
+        parent: Optional[Box] = None,
+        ref_type: Union[Any, Type[Any]] = Any,
+        key_type: Union[Any, Type[Any]] = Any,
+        element_type: Union[Any, Type[Any]] = Any,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> None:
+        try:
+            if isinstance(content, DictConfig):
+                if flags is None:
+                    flags = content._metadata.flags
+            super().__init__(
+                parent=parent,
+                metadata=ContainerMetadata(
+                    key=key,
+                    optional=is_optional,
+                    ref_type=ref_type,
+                    object_type=dict,
+                    key_type=key_type,
+                    element_type=element_type,
+                    flags=flags,
+                ),
+            )
+
+            if not _valid_dict_key_annotation_type(key_type):
+                raise KeyValidationError(f"Unsupported key type {key_type}")
+
+            if is_structured_config(content) or is_structured_config(ref_type):
+                self._set_value(content, flags=flags)
+                if is_structured_config_frozen(content) or is_structured_config_frozen(
+                    ref_type
+                ):
+                    self._set_flag("readonly", True)
+
+            else:
+                if isinstance(content, DictConfig):
+                    metadata = copy.deepcopy(content._metadata)
+                    metadata.key = key
+                    metadata.ref_type = ref_type
+                    metadata.optional = is_optional
+                    metadata.element_type = element_type
+                    metadata.key_type = key_type
+                    self.__dict__["_metadata"] = metadata
+                self._set_value(content, flags=flags)
+        except Exception as ex:
+            format_and_raise(node=None, key=key, value=None, cause=ex, msg=str(ex))
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "DictConfig":
+        res = DictConfig(None)
+        res.__dict__["_metadata"] = copy.deepcopy(self.__dict__["_metadata"], memo=memo)
+        res.__dict__["_flags_cache"] = copy.deepcopy(
+            self.__dict__["_flags_cache"], memo=memo
+        )
+
+        src_content = self.__dict__["_content"]
+        if isinstance(src_content, dict):
+            content_copy = {}
+            for k, v in src_content.items():
+                old_parent = v.__dict__["_parent"]
+                try:
+                    v.__dict__["_parent"] = None
+                    vc = copy.deepcopy(v, memo=memo)
+                    vc.__dict__["_parent"] = res
+                    content_copy[k] = vc
+                finally:
+                    v.__dict__["_parent"] = old_parent
+        else:
+            # None and strings can be assigned as is
+            content_copy = src_content
+
+        res.__dict__["_content"] = content_copy
+        # parent is retained, but not copied
+        res.__dict__["_parent"] = self.__dict__["_parent"]
+        return res
+
+    def copy(self) -> "DictConfig":
+        return copy.copy(self)
+
+    def _is_typed(self) -> bool:
+        return self._metadata.object_type not in (Any, None) and not is_dict(
+            self._metadata.object_type
+        )
+
+    def _validate_get(self, key: Any, value: Any = None) -> None:
+        is_typed = self._is_typed()
+
+        is_struct = self._get_flag("struct") is True
+        if key not in self.__dict__["_content"]:
+            if is_typed:
+                # do not raise an exception if struct is explicitly set to False
+                if self._get_node_flag("struct") is False:
+                    return
+            if is_typed or is_struct:
+                if is_typed:
+                    assert self._metadata.object_type not in (dict, None)
+                    msg = f"Key '{key}' not in '{self._metadata.object_type.__name__}'"
+                else:
+                    msg = f"Key '{key}' is not in struct"
+                self._format_and_raise(
+                    key=key, value=value, cause=ConfigAttributeError(msg)
+                )
+
+    def _validate_set(self, key: Any, value: Any) -> None:
+        from omegaconf import OmegaConf
+
+        vk = get_value_kind(value)
+        if vk == ValueKind.INTERPOLATION:
+            return
+        if _is_none(value):
+            self._validate_non_optional(key, value)
+            return
+        if vk == ValueKind.MANDATORY_MISSING or value is None:
+            return
+
+        target = self._get_node(key) if key is not None else self
+
+        target_has_ref_type = isinstance(
+            target, DictConfig
+        ) and target._metadata.ref_type not in (Any, dict)
+        is_valid_target = target is None or not target_has_ref_type
+
+        if is_valid_target:
+            return
+
+        assert isinstance(target, Node)
+
+        target_type = target._metadata.ref_type
+        value_type = OmegaConf.get_type(value)
+
+        if is_dict(value_type) and is_dict(target_type):
+            return
+        if is_container_annotation(target_type) and not is_container_annotation(
+            value_type
+        ):
+            raise ValidationError(
+                f"Cannot assign {type_str(value_type)} to {type_str(target_type)}"
+            )
+
+        if target_type is not None and value_type is not None:
+            origin = getattr(target_type, "__origin__", target_type)
+            if not issubclass(value_type, origin):
+                self._raise_invalid_value(value, value_type, target_type)
+
+    def _validate_merge(self, value: Any) -> None:
+        from omegaconf import OmegaConf
+
+        dest = self
+        src = value
+
+        self._validate_non_optional(None, src)
+
+        dest_obj_type = OmegaConf.get_type(dest)
+        src_obj_type = OmegaConf.get_type(src)
+
+        if dest._is_missing() and src._metadata.object_type not in (dict, None):
+            self._validate_set(key=None, value=_get_value(src))
+
+        if src._is_missing():
+            return
+
+        validation_error = (
+            dest_obj_type is not None
+            and src_obj_type is not None
+            and is_structured_config(dest_obj_type)
+            and not src._is_none()
+            and not is_dict(src_obj_type)
+            and not issubclass(src_obj_type, dest_obj_type)
+        )
+        if validation_error:
+            msg = (
+                f"Merge error: {type_str(src_obj_type)} is not a "
+                f"subclass of {type_str(dest_obj_type)}. value: {src}"
+            )
+            raise ValidationError(msg)
+
+    def _validate_non_optional(self, key: Optional[DictKeyType], value: Any) -> None:
+        if _is_none(value, resolve=True, throw_on_resolution_failure=False):
+
+            if key is not None:
+                child = self._get_node(key)
+                if child is not None:
+                    assert isinstance(child, Node)
+                    field_is_optional = child._is_optional()
+                else:
+                    field_is_optional, _ = _resolve_optional(
+                        self._metadata.element_type
+                    )
+            else:
+                field_is_optional = self._is_optional()
+
+            if not field_is_optional:
+                self._format_and_raise(
+                    key=key,
+                    value=value,
+                    cause=ValidationError("field '$FULL_KEY' is not Optional"),
+                )
+
+    def _raise_invalid_value(
+        self, value: Any, value_type: Any, target_type: Any
+    ) -> None:
+        assert value_type is not None
+        assert target_type is not None
+        msg = (
+            f"Invalid type assigned: {type_str(value_type)} is not a "
+            f"subclass of {type_str(target_type)}. value: {value}"
+        )
+        raise ValidationError(msg)
+
+    def _validate_and_normalize_key(self, key: Any) -> DictKeyType:
+        return self._s_validate_and_normalize_key(self._metadata.key_type, key)
+
+    def _s_validate_and_normalize_key(self, key_type: Any, key: Any) -> DictKeyType:
+        if key_type is Any:
+            for t in DictKeyType.__args__:  # type: ignore
+                if isinstance(key, t):
+                    return key  # type: ignore
+            raise KeyValidationError("Incompatible key type '$KEY_TYPE'")
+        elif key_type is bool and key in [0, 1]:
+            # Python treats True as 1 and False as 0 when used as dict keys
+            #   assert hash(0) == hash(False)
+            #   assert hash(1) == hash(True)
+            return bool(key)
+        elif key_type in (str, bytes, int, float, bool):  # primitive type
+            if not isinstance(key, key_type):
+                raise KeyValidationError(
+                    f"Key $KEY ($KEY_TYPE) is incompatible with ({key_type.__name__})"
+                )
+
+            return key  # type: ignore
+        elif issubclass(key_type, Enum):
+            try:
+                return EnumNode.validate_and_convert_to_enum(key_type, key)
+            except ValidationError:
+                valid = ", ".join([x for x in key_type.__members__.keys()])
+                raise KeyValidationError(
+                    f"Key '$KEY' is incompatible with the enum type '{key_type.__name__}', valid: [{valid}]"
+                )
+        else:
+            assert False, f"Unsupported key type {key_type}"
+
+    def __setitem__(self, key: DictKeyType, value: Any) -> None:
+        try:
+            self.__set_impl(key=key, value=value)
+        except AttributeError as e:
+            self._format_and_raise(
+                key=key, value=value, type_override=ConfigKeyError, cause=e
+            )
+        except Exception as e:
+            self._format_and_raise(key=key, value=value, cause=e)
+
+    def __set_impl(self, key: DictKeyType, value: Any) -> None:
+        key = self._validate_and_normalize_key(key)
+        self._set_item_impl(key, value)
+
+    # hide content while inspecting in debugger
+    def __dir__(self) -> Iterable[str]:
+        if self._is_missing() or self._is_none():
+            return []
+        return self.__dict__["_content"].keys()  # type: ignore
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        Allow assigning attributes to DictConfig
+        :param key:
+        :param value:
+        :return:
+        """
+        try:
+            self.__set_impl(key, value)
+        except Exception as e:
+            if isinstance(e, OmegaConfBaseException) and e._initialized:
+                raise e
+            self._format_and_raise(key=key, value=value, cause=e)
+            assert False
+
+    def __getattr__(self, key: str) -> Any:
+        """
+        Allow accessing dictionary values as attributes
+        :param key:
+        :return:
+        """
+        if key == "__name__":
+            raise AttributeError()
+
+        try:
+            return self._get_impl(
+                key=key, default_value=_DEFAULT_MARKER_, validate_key=False
+            )
+        except ConfigKeyError as e:
+            self._format_and_raise(
+                key=key, value=None, cause=e, type_override=ConfigAttributeError
+            )
+        except Exception as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def __getitem__(self, key: DictKeyType) -> Any:
+        """
+        Allow map style access
+        :param key:
+        :return:
+        """
+
+        try:
+            return self._get_impl(key=key, default_value=_DEFAULT_MARKER_)
+        except AttributeError as e:
+            self._format_and_raise(
+                key=key, value=None, cause=e, type_override=ConfigKeyError
+            )
+        except Exception as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def __delattr__(self, key: str) -> None:
+        """
+        Allow deleting dictionary values as attributes
+        :param key:
+        :return:
+        """
+        if self._get_flag("readonly"):
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ReadonlyConfigError(
+                    "DictConfig in read-only mode does not support deletion"
+                ),
+            )
+        try:
+            del self.__dict__["_content"][key]
+        except KeyError:
+            msg = "Attribute not found: '$KEY'"
+            self._format_and_raise(key=key, value=None, cause=ConfigAttributeError(msg))
+
+    def __delitem__(self, key: DictKeyType) -> None:
+        key = self._validate_and_normalize_key(key)
+        if self._get_flag("readonly"):
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ReadonlyConfigError(
+                    "DictConfig in read-only mode does not support deletion"
+                ),
+            )
+        if self._get_flag("struct"):
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ConfigTypeError(
+                    "DictConfig in struct mode does not support deletion"
+                ),
+            )
+        if self._is_typed() and self._get_node_flag("struct") is not False:
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ConfigTypeError(
+                    f"{type_str(self._metadata.object_type)} (DictConfig) does not support deletion"
+                ),
+            )
+
+        try:
+            del self.__dict__["_content"][key]
+        except KeyError:
+            msg = "Key not found: '$KEY'"
+            self._format_and_raise(key=key, value=None, cause=ConfigKeyError(msg))
+
+    def get(self, key: DictKeyType, default_value: Any = None) -> Any:
+        """Return the value for `key` if `key` is in the dictionary, else
+        `default_value` (defaulting to `None`)."""
+        try:
+            return self._get_impl(key=key, default_value=default_value)
+        except KeyValidationError as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def _get_impl(
+        self, key: DictKeyType, default_value: Any, validate_key: bool = True
+    ) -> Any:
+        try:
+            node = self._get_child(
+                key=key, throw_on_missing_key=True, validate_key=validate_key
+            )
+        except (ConfigAttributeError, ConfigKeyError):
+            if default_value is not _DEFAULT_MARKER_:
+                return default_value
+            else:
+                raise
+        assert isinstance(node, Node)
+        return self._resolve_with_default(
+            key=key, value=node, default_value=default_value
+        )
+
+    def _get_node(
+        self,
+        key: DictKeyType,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Optional[Node]:
+        try:
+            key = self._validate_and_normalize_key(key)
+        except KeyValidationError:
+            if validate_access and validate_key:
+                raise
+            else:
+                if throw_on_missing_key:
+                    raise ConfigAttributeError
+                else:
+                    return None
+
+        if validate_access:
+            self._validate_get(key)
+
+        value: Optional[Node] = self.__dict__["_content"].get(key)
+        if value is None:
+            if throw_on_missing_key:
+                raise ConfigKeyError(f"Missing key {key!s}")
+        elif throw_on_missing_value and value._is_missing():
+            raise MissingMandatoryValue("Missing mandatory value: $KEY")
+        return value
+
+    def pop(self, key: DictKeyType, default: Any = _DEFAULT_MARKER_) -> Any:
+        try:
+            if self._get_flag("readonly"):
+                raise ReadonlyConfigError("Cannot pop from read-only node")
+            if self._get_flag("struct"):
+                raise ConfigTypeError("DictConfig in struct mode does not support pop")
+            if self._is_typed() and self._get_node_flag("struct") is not False:
+                raise ConfigTypeError(
+                    f"{type_str(self._metadata.object_type)} (DictConfig) does not support pop"
+                )
+            key = self._validate_and_normalize_key(key)
+            node = self._get_child(key=key, validate_access=False)
+            if node is not None:
+                assert isinstance(node, Node)
+                value = self._resolve_with_default(
+                    key=key, value=node, default_value=default
+                )
+
+                del self[key]
+                return value
+            else:
+                if default is not _DEFAULT_MARKER_:
+                    return default
+                else:
+                    full = self._get_full_key(key=key)
+                    if full != key:
+                        raise ConfigKeyError(
+                            f"Key not found: '{key!s}' (path: '{full}')"
+                        )
+                    else:
+                        raise ConfigKeyError(f"Key not found: '{key!s}'")
+        except Exception as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def keys(self) -> KeysView[DictKeyType]:
+        if self._is_missing() or self._is_interpolation() or self._is_none():
+            return {}.keys()
+        ret = self.__dict__["_content"].keys()
+        assert isinstance(ret, KeysView)
+        return ret
+
+    def __contains__(self, key: object) -> bool:
+        """
+        A key is contained in a DictConfig if there is an associated value and
+        it is not a mandatory missing value ('???').
+        :param key:
+        :return:
+        """
+
+        try:
+            key = self._validate_and_normalize_key(key)
+        except KeyValidationError:
+            return False
+
+        try:
+            node = self._get_child(key)
+            assert node is None or isinstance(node, Node)
+        except (KeyError, AttributeError):
+            node = None
+
+        if node is None:
+            return False
+        else:
+            try:
+                self._resolve_with_default(key=key, value=node)
+                return True
+            except InterpolationResolutionError:
+                # Interpolations that fail count as existing.
+                return True
+            except MissingMandatoryValue:
+                # Missing values count as *not* existing.
+                return False
+
+    def __iter__(self) -> Iterator[DictKeyType]:
+        return iter(self.keys())
+
+    def items(self) -> ItemsView[DictKeyType, Any]:
+        return dict(self.items_ex(resolve=True, keys=None)).items()
+
+    def setdefault(self, key: DictKeyType, default: Any = None) -> Any:
+        if key in self:
+            ret = self.__getitem__(key)
+        else:
+            ret = default
+            self.__setitem__(key, default)
+        return ret
+
+    def items_ex(
+        self, resolve: bool = True, keys: Optional[Sequence[DictKeyType]] = None
+    ) -> List[Tuple[DictKeyType, Any]]:
+        items: List[Tuple[DictKeyType, Any]] = []
+
+        if self._is_none():
+            self._format_and_raise(
+                key=None,
+                value=None,
+                cause=TypeError("Cannot iterate a DictConfig object representing None"),
+            )
+        if self._is_missing():
+            raise MissingMandatoryValue("Cannot iterate a missing DictConfig")
+
+        for key in self.keys():
+            if resolve:
+                value = self[key]
+            else:
+                value = self.__dict__["_content"][key]
+                if isinstance(value, ValueNode):
+                    value = value._value()
+            if keys is None or key in keys:
+                items.append((key, value))
+
+        return items
+
+    def __eq__(self, other: Any) -> bool:
+        if other is None:
+            return self.__dict__["_content"] is None
+        if is_primitive_dict(other) or is_structured_config(other):
+            other = DictConfig(other, flags={"allow_objects": True})
+            return DictConfig._dict_conf_eq(self, other)
+        if isinstance(other, DictConfig):
+            return DictConfig._dict_conf_eq(self, other)
+        if self._is_missing():
+            return _is_missing_literal(other)
+        return NotImplemented
+
+    def __ne__(self, other: Any) -> bool:
+        x = self.__eq__(other)
+        if x is not NotImplemented:
+            return not x
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def _promote(self, type_or_prototype: Optional[Type[Any]]) -> None:
+        """
+        Retypes a node.
+        This should only be used in rare circumstances, where you want to dynamically change
+        the runtime structured-type of a DictConfig.
+        It will change the type and add the additional fields based on the input class or object
+        """
+        if type_or_prototype is None:
+            return
+        if not is_structured_config(type_or_prototype):
+            raise ValueError(f"Expected structured config class: {type_or_prototype}")
+
+        from omegaconf import OmegaConf
+
+        proto: DictConfig = OmegaConf.structured(type_or_prototype)
+        object_type = proto._metadata.object_type
+        # remove the type to prevent assignment validation from rejecting the promotion.
+        proto._metadata.object_type = None
+        self.merge_with(proto)
+        # restore the type.
+        self._metadata.object_type = object_type
+
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        try:
+            previous_content = self.__dict__["_content"]
+            self._set_value_impl(value, flags)
+        except Exception as e:
+            self.__dict__["_content"] = previous_content
+            raise e
+
+    def _set_value_impl(
+        self, value: Any, flags: Optional[Dict[str, bool]] = None
+    ) -> None:
+        from omegaconf import MISSING, flag_override
+
+        if flags is None:
+            flags = {}
+
+        assert not isinstance(value, ValueNode)
+        self._validate_set(key=None, value=value)
+
+        if _is_none(value, resolve=True):
+            self.__dict__["_content"] = None
+            self._metadata.object_type = None
+        elif _is_interpolation(value, strict_interpolation_validation=True):
+            self.__dict__["_content"] = value
+            self._metadata.object_type = None
+        elif _is_missing_value(value):
+            self.__dict__["_content"] = MISSING
+            self._metadata.object_type = None
+        else:
+            self.__dict__["_content"] = {}
+            if is_structured_config(value):
+                self._metadata.object_type = None
+                ao = self._get_flag("allow_objects")
+                data = get_structured_config_data(value, allow_objects=ao)
+                with flag_override(self, ["struct", "readonly"], False):
+                    for k, v in data.items():
+                        self.__setitem__(k, v)
+                self._metadata.object_type = get_type_of(value)
+
+            elif isinstance(value, DictConfig):
+                self._metadata.flags = copy.deepcopy(flags)
+                with flag_override(self, ["struct", "readonly"], False):
+                    for k, v in value.__dict__["_content"].items():
+                        self.__setitem__(k, v)
+                self._metadata.object_type = value._metadata.object_type
+
+            elif isinstance(value, dict):
+                with flag_override(self, ["struct", "readonly"], False):
+                    for k, v in value.items():
+                        self.__setitem__(k, v)
+                self._metadata.object_type = dict
+
+            else:  # pragma: no cover
+                msg = f"Unsupported value type: {value}"
+                raise ValidationError(msg)
+
+    @staticmethod
+    def _dict_conf_eq(d1: "DictConfig", d2: "DictConfig") -> bool:
+
+        d1_none = d1.__dict__["_content"] is None
+        d2_none = d2.__dict__["_content"] is None
+        if d1_none and d2_none:
+            return True
+        if d1_none != d2_none:
+            return False
+
+        assert isinstance(d1, DictConfig)
+        assert isinstance(d2, DictConfig)
+        if len(d1) != len(d2):
+            return False
+        if d1._is_missing() or d2._is_missing():
+            return d1._is_missing() is d2._is_missing()
+
+        for k, v in d1.items_ex(resolve=False):
+            if k not in d2.__dict__["_content"]:
+                return False
+            if not BaseContainer._item_eq(d1, k, d2, k):
+                return False
+
+        return True
+
+    def _to_object(self) -> Any:
+        """
+        Instantiate an instance of `self._metadata.object_type`.
+        This requires `self` to be a structured config.
+        Nested subconfigs are converted by calling `OmegaConf.to_object`.
+        """
+        from omegaconf import OmegaConf
+
+        object_type = self._metadata.object_type
+        assert is_structured_config(object_type)
+        init_field_names = set(get_structured_config_init_field_names(object_type))
+
+        init_field_items: Dict[str, Any] = {}
+        non_init_field_items: Dict[str, Any] = {}
+        for k in self.keys():
+            assert isinstance(k, str)
+            node = self._get_child(k)
+            assert isinstance(node, Node)
+            try:
+                node = node._dereference_node()
+            except InterpolationResolutionError as e:
+                self._format_and_raise(key=k, value=None, cause=e)
+            if node._is_missing():
+                if k not in init_field_names:
+                    continue  # MISSING is ignored for init=False fields
+                self._format_and_raise(
+                    key=k,
+                    value=None,
+                    cause=MissingMandatoryValue(
+                        "Structured config of type `$OBJECT_TYPE` has missing mandatory value: $KEY"
+                    ),
+                )
+            if isinstance(node, Container):
+                v = OmegaConf.to_object(node)
+            else:
+                v = node._value()
+
+            if k in init_field_names:
+                init_field_items[k] = v
+            else:
+                non_init_field_items[k] = v
+
+        try:
+            result = object_type(**init_field_items)
+        except TypeError as exc:
+            self._format_and_raise(
+                key=None,
+                value=None,
+                cause=exc,
+                msg="Could not create instance of `$OBJECT_TYPE`: " + str(exc),
+            )
+
+        for k, v in non_init_field_items.items():
+            setattr(result, k, v)
+        return result

lib/python3.12/site-packages/omegaconf/errors.py

@@ -0,0 +1,141 @@
+from typing import Any, Optional, Type
+
+
+class OmegaConfBaseException(Exception):
+    # would ideally be typed Optional[Node]
+    parent_node: Any
+    child_node: Any
+    key: Any
+    full_key: Optional[str]
+    value: Any
+    msg: Optional[str]
+    cause: Optional[Exception]
+    object_type: Optional[Type[Any]]
+    object_type_str: Optional[str]
+    ref_type: Optional[Type[Any]]
+    ref_type_str: Optional[str]
+
+    _initialized: bool = False
+
+    def __init__(self, *_args: Any, **_kwargs: Any) -> None:
+        self.parent_node = None
+        self.child_node = None
+        self.key = None
+        self.full_key = None
+        self.value = None
+        self.msg = None
+        self.object_type = None
+        self.ref_type = None
+
+
+class MissingMandatoryValue(OmegaConfBaseException):
+    """Thrown when a variable flagged with '???' value is accessed to
+    indicate that the value was not set"""
+
+
+class KeyValidationError(OmegaConfBaseException, ValueError):
+    """
+    Thrown when an a key of invalid type is used
+    """
+
+
+class ValidationError(OmegaConfBaseException, ValueError):
+    """
+    Thrown when a value fails validation
+    """
+
+
+class UnsupportedValueType(ValidationError, ValueError):
+    """
+    Thrown when an input value is not of supported type
+    """
+
+
+class ReadonlyConfigError(OmegaConfBaseException):
+    """
+    Thrown when someone tries to modify a frozen config
+    """
+
+
+class InterpolationResolutionError(OmegaConfBaseException, ValueError):
+    """
+    Base class for exceptions raised when resolving an interpolation.
+    """
+
+
+class UnsupportedInterpolationType(InterpolationResolutionError):
+    """
+    Thrown when an attempt to use an unregistered interpolation is made
+    """
+
+
+class InterpolationKeyError(InterpolationResolutionError):
+    """
+    Thrown when a node does not exist when resolving an interpolation.
+    """
+
+
+class InterpolationToMissingValueError(InterpolationResolutionError):
+    """
+    Thrown when a node interpolation points to a node that is set to ???.
+    """
+
+
+class InterpolationValidationError(InterpolationResolutionError, ValidationError):
+    """
+    Thrown when the result of an interpolation fails the validation step.
+    """
+
+
+class ConfigKeyError(OmegaConfBaseException, KeyError):
+    """
+    Thrown from DictConfig when a regular dict access would have caused a KeyError.
+    """
+
+    msg: str
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(msg)
+        self.msg = msg
+
+    def __str__(self) -> str:
+        """
+        Workaround to nasty KeyError quirk: https://bugs.python.org/issue2651
+        """
+        return self.msg
+
+
+class ConfigAttributeError(OmegaConfBaseException, AttributeError):
+    """
+    Thrown from a config object when a regular access would have caused an AttributeError.
+    """
+
+
+class ConfigTypeError(OmegaConfBaseException, TypeError):
+    """
+    Thrown from a config object when a regular access would have caused a TypeError.
+    """
+
+
+class ConfigIndexError(OmegaConfBaseException, IndexError):
+    """
+    Thrown from a config object when a regular access would have caused an IndexError.
+    """
+
+
+class ConfigValueError(OmegaConfBaseException, ValueError):
+    """
+    Thrown from a config object when a regular access would have caused a ValueError.
+    """
+
+
+class ConfigCycleDetectedException(OmegaConfBaseException):
+    """
+    Thrown when a cycle is detected in the graph made by config nodes.
+    """
+
+
+class GrammarParseError(OmegaConfBaseException):
+    """
+    Thrown when failing to parse an expression according to the ANTLR grammar.
+    """

lib/python3.12/site-packages/omegaconf/grammar/gen/OmegaConfGrammarLexer.py

@@ -0,0 +1,337 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarLexer.g4 by ANTLR 4.9.3
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\36")
+        buf.write("\u01e7\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5")
+        buf.write("\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13")
+        buf.write("\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t")
+        buf.write("\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26")
+        buf.write("\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34")
+        buf.write("\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t")
+        buf.write("\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4")
+        buf.write("+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62")
+        buf.write("\t\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\3\2\3\2")
+        buf.write("\3\3\3\3\3\4\3\4\3\4\5\4y\n\4\3\4\7\4|\n\4\f\4\16\4\177")
+        buf.write("\13\4\5\4\u0081\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3")
+        buf.write("\7\7\7\u008c\n\7\f\7\16\7\u008f\13\7\3\7\3\7\3\b\7\b\u0094")
+        buf.write("\n\b\f\b\16\b\u0097\13\b\3\b\3\b\3\b\3\b\3\t\6\t\u009e")
+        buf.write("\n\t\r\t\16\t\u009f\3\n\6\n\u00a3\n\n\r\n\16\n\u00a4\3")
+        buf.write("\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\5\f\u00b1\n")
+        buf.write("\f\3\f\3\f\3\r\3\r\5\r\u00b7\n\r\3\r\3\r\3\16\5\16\u00bc")
+        buf.write("\n\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20")
+        buf.write("\3\20\3\20\3\21\5\21\u00cb\n\21\3\21\3\21\5\21\u00cf\n")
+        buf.write("\21\3\22\3\22\5\22\u00d3\n\22\3\23\5\23\u00d6\n\23\3\23")
+        buf.write("\3\23\3\24\5\24\u00db\n\24\3\24\3\24\5\24\u00df\n\24\3")
+        buf.write("\25\3\25\3\25\3\25\5\25\u00e5\n\25\3\25\3\25\3\25\5\25")
+        buf.write("\u00ea\n\25\3\25\7\25\u00ed\n\25\f\25\16\25\u00f0\13\25")
+        buf.write("\5\25\u00f2\n\25\3\26\3\26\5\26\u00f6\n\26\3\26\3\26\5")
+        buf.write("\26\u00fa\n\26\3\26\3\26\5\26\u00fe\n\26\3\26\7\26\u0101")
+        buf.write("\n\26\f\26\16\26\u0104\13\26\3\27\5\27\u0107\n\27\3\27")
+        buf.write("\3\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u0111\n\27\3")
+        buf.write("\30\5\30\u0114\n\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\31\3\31\3\31\5\31\u0121\n\31\3\32\3\32\3\32\3")
+        buf.write("\32\3\32\3\33\3\33\3\34\3\34\5\34\u012c\n\34\3\34\3\34")
+        buf.write("\3\34\7\34\u0131\n\34\f\34\16\34\u0134\13\34\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\6\35")
+        buf.write("\u014d\n\35\r\35\16\35\u014e\3\36\6\36\u0152\n\36\r\36")
+        buf.write("\16\36\u0153\3\37\3\37\5\37\u0158\n\37\3\37\3\37\3\37")
+        buf.write("\3 \5 \u015e\n \3 \3 \5 \u0162\n \3 \3 \3 \3!\5!\u0168")
+        buf.write("\n!\3!\3!\3!\3!\3\"\3\"\3#\3#\3#\3#\3$\3$\3$\3$\3%\3%")
+        buf.write("\3%\3%\3&\6&\u017d\n&\r&\16&\u017e\3\'\3\'\3\'\3\'\3\'")
+        buf.write("\3(\3(\3(\3(\3)\7)\u018b\n)\f)\16)\u018e\13)\3)\3)\3)")
+        buf.write("\3)\3*\3*\3*\3*\3+\7+\u0199\n+\f+\16+\u019c\13+\3+\3+")
+        buf.write("\3+\3+\3+\3,\6,\u01a4\n,\r,\16,\u01a5\3-\6-\u01a9\n-\r")
+        buf.write("-\16-\u01aa\3-\3-\3.\3.\3.\3.\3/\3/\3/\3/\3/\3\60\3\60")
+        buf.write("\3\60\3\60\3\60\3\61\7\61\u01be\n\61\f\61\16\61\u01c1")
+        buf.write("\13\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\63\7")
+        buf.write("\63\u01cc\n\63\f\63\16\63\u01cf\13\63\3\63\3\63\3\63\3")
+        buf.write("\63\3\63\3\64\6\64\u01d7\n\64\r\64\16\64\u01d8\3\64\3")
+        buf.write("\64\3\65\6\65\u01de\n\65\r\65\16\65\u01df\3\65\3\65\3")
+        buf.write("\66\3\66\3\66\3\66\2\2\67\7\2\t\2\13\2\r\2\17\2\21\3\23")
+        buf.write("\4\25\5\27\2\31\34\33\6\35\7\37\b!\t#\n%\13\'\f)\r+\16")
+        buf.write("-\2/\2\61\17\63\20\65\21\67\229\23;\24=\25?\26A\2C\2E")
+        buf.write("\27G\30I\35K\36M\2O\31Q\2S\32U\2W\2Y\2[\33]\2_\2a\2c\2")
+        buf.write("e\2g\2i\2k\2m\2o\2\7\2\3\4\5\6\32\4\2C\\c|\3\2\62;\3\2")
+        buf.write("\63;\3\2&&\4\2&&^^\4\2GGgg\4\2--//\4\2KKkk\4\2PPpp\4\2")
+        buf.write("HHhh\4\2CCcc\4\2VVvv\4\2TTtt\4\2WWww\4\2NNnn\4\2UUuu\b")
+        buf.write("\2&\',-/\61AB^^~~\4\2//aa\4\2\13\13\"\"\13\2\13\13\"\"")
+        buf.write("$$)+\60\60<<]_}}\177\177\4\2&&))\5\2&&))^^\4\2$$&&\5\2")
+        buf.write("$$&&^^\2\u0218\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2")
+        buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\3\33\3\2\2\2\3")
+        buf.write("\35\3\2\2\2\3\37\3\2\2\2\3!\3\2\2\2\3#\3\2\2\2\3%\3\2")
+        buf.write("\2\2\3\'\3\2\2\2\3)\3\2\2\2\3+\3\2\2\2\3\61\3\2\2\2\3")
+        buf.write("\63\3\2\2\2\3\65\3\2\2\2\3\67\3\2\2\2\39\3\2\2\2\3;\3")
+        buf.write("\2\2\2\3=\3\2\2\2\3?\3\2\2\2\4A\3\2\2\2\4C\3\2\2\2\4E")
+        buf.write("\3\2\2\2\4G\3\2\2\2\4I\3\2\2\2\4K\3\2\2\2\4M\3\2\2\2\4")
+        buf.write("O\3\2\2\2\5Q\3\2\2\2\5S\3\2\2\2\5U\3\2\2\2\5W\3\2\2\2")
+        buf.write("\5Y\3\2\2\2\5[\3\2\2\2\5]\3\2\2\2\5_\3\2\2\2\6a\3\2\2")
+        buf.write("\2\6c\3\2\2\2\6e\3\2\2\2\6g\3\2\2\2\6i\3\2\2\2\6k\3\2")
+        buf.write("\2\2\6m\3\2\2\2\6o\3\2\2\2\7q\3\2\2\2\ts\3\2\2\2\13\u0080")
+        buf.write("\3\2\2\2\r\u0082\3\2\2\2\17\u0085\3\2\2\2\21\u008d\3\2")
+        buf.write("\2\2\23\u0095\3\2\2\2\25\u009d\3\2\2\2\27\u00a2\3\2\2")
+        buf.write("\2\31\u00a8\3\2\2\2\33\u00ac\3\2\2\2\35\u00b4\3\2\2\2")
+        buf.write("\37\u00bb\3\2\2\2!\u00c1\3\2\2\2#\u00c5\3\2\2\2%\u00ca")
+        buf.write("\3\2\2\2\'\u00d0\3\2\2\2)\u00d5\3\2\2\2+\u00da\3\2\2\2")
+        buf.write("-\u00f1\3\2\2\2/\u00f5\3\2\2\2\61\u0106\3\2\2\2\63\u0113")
+        buf.write("\3\2\2\2\65\u0120\3\2\2\2\67\u0122\3\2\2\29\u0127\3\2")
+        buf.write("\2\2;\u012b\3\2\2\2=\u014c\3\2\2\2?\u0151\3\2\2\2A\u0155")
+        buf.write("\3\2\2\2C\u015d\3\2\2\2E\u0167\3\2\2\2G\u016d\3\2\2\2")
+        buf.write("I\u016f\3\2\2\2K\u0173\3\2\2\2M\u0177\3\2\2\2O\u017c\3")
+        buf.write("\2\2\2Q\u0180\3\2\2\2S\u0185\3\2\2\2U\u018c\3\2\2\2W\u0193")
+        buf.write("\3\2\2\2Y\u019a\3\2\2\2[\u01a3\3\2\2\2]\u01a8\3\2\2\2")
+        buf.write("_\u01ae\3\2\2\2a\u01b2\3\2\2\2c\u01b7\3\2\2\2e\u01bf\3")
+        buf.write("\2\2\2g\u01c6\3\2\2\2i\u01cd\3\2\2\2k\u01d6\3\2\2\2m\u01dd")
+        buf.write("\3\2\2\2o\u01e3\3\2\2\2qr\t\2\2\2r\b\3\2\2\2st\t\3\2\2")
+        buf.write("t\n\3\2\2\2u\u0081\7\62\2\2v}\t\4\2\2wy\7a\2\2xw\3\2\2")
+        buf.write("\2xy\3\2\2\2yz\3\2\2\2z|\5\t\3\2{x\3\2\2\2|\177\3\2\2")
+        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080")
+        buf.write("u\3\2\2\2\u0080v\3\2\2\2\u0081\f\3\2\2\2\u0082\u0083\7")
+        buf.write("^\2\2\u0083\u0084\7^\2\2\u0084\16\3\2\2\2\u0085\u0086")
+        buf.write("\5\33\f\2\u0086\u0087\3\2\2\2\u0087\u0088\b\6\2\2\u0088")
+        buf.write("\u0089\b\6\3\2\u0089\20\3\2\2\2\u008a\u008c\n\5\2\2\u008b")
+        buf.write("\u008a\3\2\2\2\u008c\u008f\3\2\2\2\u008d\u008b\3\2\2\2")
+        buf.write("\u008d\u008e\3\2\2\2\u008e\u0090\3\2\2\2\u008f\u008d\3")
+        buf.write("\2\2\2\u0090\u0091\n\6\2\2\u0091\22\3\2\2\2\u0092\u0094")
+        buf.write("\5\r\5\2\u0093\u0092\3\2\2\2\u0094\u0097\3\2\2\2\u0095")
+        buf.write("\u0093\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0098\3\2\2\2")
+        buf.write("\u0097\u0095\3\2\2\2\u0098\u0099\7^\2\2\u0099\u009a\7")
+        buf.write("&\2\2\u009a\u009b\7}\2\2\u009b\24\3\2\2\2\u009c\u009e")
+        buf.write("\5\r\5\2\u009d\u009c\3\2\2\2\u009e\u009f\3\2\2\2\u009f")
+        buf.write("\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\26\3\2\2\2\u00a1")
+        buf.write("\u00a3\7^\2\2\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2")
+        buf.write("\u00a4\u00a2\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a6\3")
+        buf.write("\2\2\2\u00a6\u00a7\b\n\4\2\u00a7\30\3\2\2\2\u00a8\u00a9")
+        buf.write("\7&\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\b\13\4\2\u00ab")
+        buf.write("\32\3\2\2\2\u00ac\u00ad\7&\2\2\u00ad\u00ae\7}\2\2\u00ae")
+        buf.write("\u00b0\3\2\2\2\u00af\u00b1\5?\36\2\u00b0\u00af\3\2\2\2")
+        buf.write("\u00b0\u00b1\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\b")
+        buf.write("\f\3\2\u00b3\34\3\2\2\2\u00b4\u00b6\7}\2\2\u00b5\u00b7")
+        buf.write("\5?\36\2\u00b6\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7")
+        buf.write("\u00b8\3\2\2\2\u00b8\u00b9\b\r\5\2\u00b9\36\3\2\2\2\u00ba")
+        buf.write("\u00bc\5?\36\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2")
+        buf.write("\u00bc\u00bd\3\2\2\2\u00bd\u00be\7\177\2\2\u00be\u00bf")
+        buf.write("\3\2\2\2\u00bf\u00c0\b\16\6\2\u00c0 \3\2\2\2\u00c1\u00c2")
+        buf.write("\7)\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c4\b\17\7\2\u00c4")
+        buf.write("\"\3\2\2\2\u00c5\u00c6\7$\2\2\u00c6\u00c7\3\2\2\2\u00c7")
+        buf.write("\u00c8\b\20\b\2\u00c8$\3\2\2\2\u00c9\u00cb\5?\36\2\u00ca")
+        buf.write("\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2")
+        buf.write("\u00cc\u00ce\7.\2\2\u00cd\u00cf\5?\36\2\u00ce\u00cd\3")
+        buf.write("\2\2\2\u00ce\u00cf\3\2\2\2\u00cf&\3\2\2\2\u00d0\u00d2")
+        buf.write("\7]\2\2\u00d1\u00d3\5?\36\2\u00d2\u00d1\3\2\2\2\u00d2")
+        buf.write("\u00d3\3\2\2\2\u00d3(\3\2\2\2\u00d4\u00d6\5?\36\2\u00d5")
+        buf.write("\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00d7\3\2\2\2")
+        buf.write("\u00d7\u00d8\7_\2\2\u00d8*\3\2\2\2\u00d9\u00db\5?\36\2")
+        buf.write("\u00da\u00d9\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\3")
+        buf.write("\2\2\2\u00dc\u00de\7<\2\2\u00dd\u00df\5?\36\2\u00de\u00dd")
+        buf.write("\3\2\2\2\u00de\u00df\3\2\2\2\u00df,\3\2\2\2\u00e0\u00e1")
+        buf.write("\5\13\4\2\u00e1\u00e2\7\60\2\2\u00e2\u00f2\3\2\2\2\u00e3")
+        buf.write("\u00e5\5\13\4\2\u00e4\u00e3\3\2\2\2\u00e4\u00e5\3\2\2")
+        buf.write("\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\7\60\2\2\u00e7\u00ee")
+        buf.write("\5\t\3\2\u00e8\u00ea\7a\2\2\u00e9\u00e8\3\2\2\2\u00e9")
+        buf.write("\u00ea\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ed\5\t\3\2")
+        buf.write("\u00ec\u00e9\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3")
+        buf.write("\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee")
+        buf.write("\3\2\2\2\u00f1\u00e0\3\2\2\2\u00f1\u00e4\3\2\2\2\u00f2")
+        buf.write(".\3\2\2\2\u00f3\u00f6\5\13\4\2\u00f4\u00f6\5-\25\2\u00f5")
+        buf.write("\u00f3\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2")
+        buf.write("\u00f7\u00f9\t\7\2\2\u00f8\u00fa\t\b\2\2\u00f9\u00f8\3")
+        buf.write("\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u0102")
+        buf.write("\5\t\3\2\u00fc\u00fe\7a\2\2\u00fd\u00fc\3\2\2\2\u00fd")
+        buf.write("\u00fe\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0101\5\t\3\2")
+        buf.write("\u0100\u00fd\3\2\2\2\u0101\u0104\3\2\2\2\u0102\u0100\3")
+        buf.write("\2\2\2\u0102\u0103\3\2\2\2\u0103\60\3\2\2\2\u0104\u0102")
+        buf.write("\3\2\2\2\u0105\u0107\t\b\2\2\u0106\u0105\3\2\2\2\u0106")
+        buf.write("\u0107\3\2\2\2\u0107\u0110\3\2\2\2\u0108\u0111\5-\25\2")
+        buf.write("\u0109\u0111\5/\26\2\u010a\u010b\t\t\2\2\u010b\u010c\t")
+        buf.write("\n\2\2\u010c\u0111\t\13\2\2\u010d\u010e\t\n\2\2\u010e")
+        buf.write("\u010f\t\f\2\2\u010f\u0111\t\n\2\2\u0110\u0108\3\2\2\2")
+        buf.write("\u0110\u0109\3\2\2\2\u0110\u010a\3\2\2\2\u0110\u010d\3")
+        buf.write("\2\2\2\u0111\62\3\2\2\2\u0112\u0114\t\b\2\2\u0113\u0112")
+        buf.write("\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0115\3\2\2\2\u0115")
+        buf.write("\u0116\5\13\4\2\u0116\64\3\2\2\2\u0117\u0118\t\r\2\2\u0118")
+        buf.write("\u0119\t\16\2\2\u0119\u011a\t\17\2\2\u011a\u0121\t\7\2")
+        buf.write("\2\u011b\u011c\t\13\2\2\u011c\u011d\t\f\2\2\u011d\u011e")
+        buf.write("\t\20\2\2\u011e\u011f\t\21\2\2\u011f\u0121\t\7\2\2\u0120")
+        buf.write("\u0117\3\2\2\2\u0120\u011b\3\2\2\2\u0121\66\3\2\2\2\u0122")
+        buf.write("\u0123\t\n\2\2\u0123\u0124\t\17\2\2\u0124\u0125\t\20\2")
+        buf.write("\2\u0125\u0126\t\20\2\2\u01268\3\2\2\2\u0127\u0128\t\22")
+        buf.write("\2\2\u0128:\3\2\2\2\u0129\u012c\5\7\2\2\u012a\u012c\7")
+        buf.write("a\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u0132")
+        buf.write("\3\2\2\2\u012d\u0131\5\7\2\2\u012e\u0131\5\t\3\2\u012f")
+        buf.write("\u0131\t\23\2\2\u0130\u012d\3\2\2\2\u0130\u012e\3\2\2")
+        buf.write("\2\u0130\u012f\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130")
+        buf.write("\3\2\2\2\u0132\u0133\3\2\2\2\u0133<\3\2\2\2\u0134\u0132")
+        buf.write("\3\2\2\2\u0135\u014d\5\r\5\2\u0136\u0137\7^\2\2\u0137")
+        buf.write("\u014d\7*\2\2\u0138\u0139\7^\2\2\u0139\u014d\7+\2\2\u013a")
+        buf.write("\u013b\7^\2\2\u013b\u014d\7]\2\2\u013c\u013d\7^\2\2\u013d")
+        buf.write("\u014d\7_\2\2\u013e\u013f\7^\2\2\u013f\u014d\7}\2\2\u0140")
+        buf.write("\u0141\7^\2\2\u0141\u014d\7\177\2\2\u0142\u0143\7^\2\2")
+        buf.write("\u0143\u014d\7<\2\2\u0144\u0145\7^\2\2\u0145\u014d\7?")
+        buf.write("\2\2\u0146\u0147\7^\2\2\u0147\u014d\7.\2\2\u0148\u0149")
+        buf.write("\7^\2\2\u0149\u014d\7\"\2\2\u014a\u014b\7^\2\2\u014b\u014d")
+        buf.write("\7\13\2\2\u014c\u0135\3\2\2\2\u014c\u0136\3\2\2\2\u014c")
+        buf.write("\u0138\3\2\2\2\u014c\u013a\3\2\2\2\u014c\u013c\3\2\2\2")
+        buf.write("\u014c\u013e\3\2\2\2\u014c\u0140\3\2\2\2\u014c\u0142\3")
+        buf.write("\2\2\2\u014c\u0144\3\2\2\2\u014c\u0146\3\2\2\2\u014c\u0148")
+        buf.write("\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u014e\3\2\2\2\u014e")
+        buf.write("\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f>\3\2\2\2\u0150")
+        buf.write("\u0152\t\24\2\2\u0151\u0150\3\2\2\2\u0152\u0153\3\2\2")
+        buf.write("\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154@\3\2")
+        buf.write("\2\2\u0155\u0157\5\33\f\2\u0156\u0158\5?\36\2\u0157\u0156")
+        buf.write("\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0159\3\2\2\2\u0159")
+        buf.write("\u015a\b\37\2\2\u015a\u015b\b\37\3\2\u015bB\3\2\2\2\u015c")
+        buf.write("\u015e\5?\36\2\u015d\u015c\3\2\2\2\u015d\u015e\3\2\2\2")
+        buf.write("\u015e\u015f\3\2\2\2\u015f\u0161\7<\2\2\u0160\u0162\5")
+        buf.write("?\36\2\u0161\u0160\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163")
+        buf.write("\3\2\2\2\u0163\u0164\b \t\2\u0164\u0165\b \n\2\u0165D")
+        buf.write("\3\2\2\2\u0166\u0168\5?\36\2\u0167\u0166\3\2\2\2\u0167")
+        buf.write("\u0168\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\7\177\2")
+        buf.write("\2\u016a\u016b\3\2\2\2\u016b\u016c\b!\6\2\u016cF\3\2\2")
+        buf.write("\2\u016d\u016e\7\60\2\2\u016eH\3\2\2\2\u016f\u0170\7]")
+        buf.write("\2\2\u0170\u0171\3\2\2\2\u0171\u0172\b#\13\2\u0172J\3")
+        buf.write("\2\2\2\u0173\u0174\7_\2\2\u0174\u0175\3\2\2\2\u0175\u0176")
+        buf.write("\b$\f\2\u0176L\3\2\2\2\u0177\u0178\5;\34\2\u0178\u0179")
+        buf.write("\3\2\2\2\u0179\u017a\b%\r\2\u017aN\3\2\2\2\u017b\u017d")
+        buf.write("\n\25\2\2\u017c\u017b\3\2\2\2\u017d\u017e\3\2\2\2\u017e")
+        buf.write("\u017c\3\2\2\2\u017e\u017f\3\2\2\2\u017fP\3\2\2\2\u0180")
+        buf.write("\u0181\5\33\f\2\u0181\u0182\3\2\2\2\u0182\u0183\b\'\2")
+        buf.write("\2\u0183\u0184\b\'\3\2\u0184R\3\2\2\2\u0185\u0186\7)\2")
+        buf.write("\2\u0186\u0187\3\2\2\2\u0187\u0188\b(\6\2\u0188T\3\2\2")
+        buf.write("\2\u0189\u018b\n\26\2\2\u018a\u0189\3\2\2\2\u018b\u018e")
+        buf.write("\3\2\2\2\u018c\u018a\3\2\2\2\u018c\u018d\3\2\2\2\u018d")
+        buf.write("\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f\u0190\n\27\2")
+        buf.write("\2\u0190\u0191\3\2\2\2\u0191\u0192\b)\4\2\u0192V\3\2\2")
+        buf.write("\2\u0193\u0194\5\23\b\2\u0194\u0195\3\2\2\2\u0195\u0196")
+        buf.write("\b*\16\2\u0196X\3\2\2\2\u0197\u0199\5\r\5\2\u0198\u0197")
+        buf.write("\3\2\2\2\u0199\u019c\3\2\2\2\u019a\u0198\3\2\2\2\u019a")
+        buf.write("\u019b\3\2\2\2\u019b\u019d\3\2\2\2\u019c\u019a\3\2\2\2")
+        buf.write("\u019d\u019e\7^\2\2\u019e\u019f\7)\2\2\u019f\u01a0\3\2")
+        buf.write("\2\2\u01a0\u01a1\b+\17\2\u01a1Z\3\2\2\2\u01a2\u01a4\5")
+        buf.write("\r\5\2\u01a3\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a3")
+        buf.write("\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\\\3\2\2\2\u01a7\u01a9")
+        buf.write("\7^\2\2\u01a8\u01a7\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa")
+        buf.write("\u01a8\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\3\2\2\2")
+        buf.write("\u01ac\u01ad\b-\4\2\u01ad^\3\2\2\2\u01ae\u01af\7&\2\2")
+        buf.write("\u01af\u01b0\3\2\2\2\u01b0\u01b1\b.\4\2\u01b1`\3\2\2\2")
+        buf.write("\u01b2\u01b3\5\33\f\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5")
+        buf.write("\b/\2\2\u01b5\u01b6\b/\3\2\u01b6b\3\2\2\2\u01b7\u01b8")
+        buf.write("\7$\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\b\60\20\2\u01ba")
+        buf.write("\u01bb\b\60\6\2\u01bbd\3\2\2\2\u01bc\u01be\n\30\2\2\u01bd")
+        buf.write("\u01bc\3\2\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2")
+        buf.write("\u01bf\u01c0\3\2\2\2\u01c0\u01c2\3\2\2\2\u01c1\u01bf\3")
+        buf.write("\2\2\2\u01c2\u01c3\n\31\2\2\u01c3\u01c4\3\2\2\2\u01c4")
+        buf.write("\u01c5\b\61\4\2\u01c5f\3\2\2\2\u01c6\u01c7\5\23\b\2\u01c7")
+        buf.write("\u01c8\3\2\2\2\u01c8\u01c9\b\62\16\2\u01c9h\3\2\2\2\u01ca")
+        buf.write("\u01cc\5\r\5\2\u01cb\u01ca\3\2\2\2\u01cc\u01cf\3\2\2\2")
+        buf.write("\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01d0\3")
+        buf.write("\2\2\2\u01cf\u01cd\3\2\2\2\u01d0\u01d1\7^\2\2\u01d1\u01d2")
+        buf.write("\7$\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\b\63\17\2\u01d4")
+        buf.write("j\3\2\2\2\u01d5\u01d7\5\r\5\2\u01d6\u01d5\3\2\2\2\u01d7")
+        buf.write("\u01d8\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2")
+        buf.write("\u01d9\u01da\3\2\2\2\u01da\u01db\b\64\21\2\u01dbl\3\2")
+        buf.write("\2\2\u01dc\u01de\7^\2\2\u01dd\u01dc\3\2\2\2\u01de\u01df")
+        buf.write("\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0")
+        buf.write("\u01e1\3\2\2\2\u01e1\u01e2\b\65\4\2\u01e2n\3\2\2\2\u01e3")
+        buf.write("\u01e4\7&\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\b\66\4\2")
+        buf.write("\u01e6p\3\2\2\2\66\2\3\4\5\6x}\u0080\u008d\u0095\u009f")
+        buf.write("\u00a4\u00b0\u00b6\u00bb\u00ca\u00ce\u00d2\u00d5\u00da")
+        buf.write("\u00de\u00e4\u00e9\u00ee\u00f1\u00f5\u00f9\u00fd\u0102")
+        buf.write("\u0106\u0110\u0113\u0120\u012b\u0130\u0132\u014c\u014e")
+        buf.write("\u0153\u0157\u015d\u0161\u0167\u017e\u018c\u019a\u01a5")
+        buf.write("\u01aa\u01bf\u01cd\u01d8\u01df\22\t\6\2\7\4\2\t\3\2\7")
+        buf.write("\3\2\6\2\2\7\5\2\7\6\2\t\16\2\4\3\2\t\f\2\t\r\2\t\24\2")
+        buf.write("\t\4\2\t\25\2\t\32\2\t\33\2")
+        return buf.getvalue()
+
+
+class OmegaConfGrammarLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    VALUE_MODE = 1
+    INTERPOLATION_MODE = 2
+    QUOTED_SINGLE_MODE = 3
+    QUOTED_DOUBLE_MODE = 4
+
+    ANY_STR = 1
+    ESC_INTER = 2
+    TOP_ESC = 3
+    INTER_OPEN = 4
+    BRACE_OPEN = 5
+    BRACE_CLOSE = 6
+    QUOTE_OPEN_SINGLE = 7
+    QUOTE_OPEN_DOUBLE = 8
+    COMMA = 9
+    BRACKET_OPEN = 10
+    BRACKET_CLOSE = 11
+    COLON = 12
+    FLOAT = 13
+    INT = 14
+    BOOL = 15
+    NULL = 16
+    UNQUOTED_CHAR = 17
+    ID = 18
+    ESC = 19
+    WS = 20
+    INTER_CLOSE = 21
+    DOT = 22
+    INTER_KEY = 23
+    MATCHING_QUOTE_CLOSE = 24
+    QUOTED_ESC = 25
+    DOLLAR = 26
+    INTER_BRACKET_OPEN = 27
+    INTER_BRACKET_CLOSE = 28
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE", "VALUE_MODE", "INTERPOLATION_MODE", "QUOTED_SINGLE_MODE", 
+                  "QUOTED_DOUBLE_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'.'", "'['", "']'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", "BRACE_OPEN", 
+            "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", "QUOTE_OPEN_DOUBLE", "COMMA", 
+            "BRACKET_OPEN", "BRACKET_CLOSE", "COLON", "FLOAT", "INT", "BOOL", 
+            "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "INTER_CLOSE", "DOT", 
+            "INTER_KEY", "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", 
+            "INTER_BRACKET_OPEN", "INTER_BRACKET_CLOSE" ]
+
+    ruleNames = [ "CHAR", "DIGIT", "INT_UNSIGNED", "ESC_BACKSLASH", "TOP_INTER_OPEN", 
+                  "ANY_STR", "ESC_INTER", "TOP_ESC", "BACKSLASHES", "DOLLAR", 
+                  "INTER_OPEN", "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", 
+                  "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", 
+                  "COLON", "POINT_FLOAT", "EXPONENT_FLOAT", "FLOAT", "INT", 
+                  "BOOL", "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "NESTED_INTER_OPEN", 
+                  "INTER_COLON", "INTER_CLOSE", "DOT", "INTER_BRACKET_OPEN", 
+                  "INTER_BRACKET_CLOSE", "INTER_ID", "INTER_KEY", "QSINGLE_INTER_OPEN", 
+                  "MATCHING_QUOTE_CLOSE", "QSINGLE_STR", "QSINGLE_ESC_INTER", 
+                  "QSINGLE_ESC_QUOTE", "QUOTED_ESC", "QSINGLE_BACKSLASHES", 
+                  "QSINGLE_DOLLAR", "QDOUBLE_INTER_OPEN", "QDOUBLE_CLOSE", 
+                  "QDOUBLE_STR", "QDOUBLE_ESC_INTER", "QDOUBLE_ESC_QUOTE", 
+                  "QDOUBLE_ESC", "QDOUBLE_BACKSLASHES", "QDOUBLE_DOLLAR" ]
+
+    grammarFileName = "OmegaConfGrammarLexer.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.9.3")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

lib/python3.12/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py

@@ -0,0 +1,1595 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+	from typing import TextIO
+else:
+	from typing.io import TextIO
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\36")
+        buf.write("\u00b7\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
+        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3\2\3\3\3")
+        buf.write("\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\6\4/\n\4\r\4\16\4\60\3")
+        buf.write("\5\3\5\3\5\3\5\5\5\67\n\5\3\6\3\6\5\6;\n\6\3\6\3\6\3\7")
+        buf.write("\3\7\3\7\3\7\7\7C\n\7\f\7\16\7F\13\7\5\7H\n\7\3\7\3\7")
+        buf.write("\3\b\3\b\3\b\3\b\3\t\3\t\3\t\5\tS\n\t\7\tU\n\t\f\t\16")
+        buf.write("\tX\13\t\3\t\3\t\5\t\\\n\t\6\t^\n\t\r\t\16\t_\5\tb\n\t")
+        buf.write("\3\n\3\n\5\nf\n\n\3\13\3\13\7\13j\n\13\f\13\16\13m\13")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\5\13t\n\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\7\13|\n\13\f\13\16\13\177\13\13\3\13\3")
+        buf.write("\13\3\f\3\f\3\f\3\f\5\f\u0087\n\f\3\f\3\f\3\r\3\r\3\r")
+        buf.write("\5\r\u008e\n\r\3\16\3\16\5\16\u0092\n\16\3\16\3\16\3\16")
+        buf.write("\5\16\u0097\n\16\7\16\u0099\n\16\f\16\16\16\u009c\13\16")
+        buf.write("\3\17\3\17\5\17\u00a0\n\17\3\17\3\17\3\20\3\20\3\20\3")
+        buf.write("\20\3\20\3\20\3\20\3\20\3\20\3\20\6\20\u00ae\n\20\r\20")
+        buf.write("\16\20\u00af\3\21\6\21\u00b3\n\21\r\21\16\21\u00b4\3\21")
+        buf.write("\2\2\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \2\4\3")
+        buf.write("\2\t\n\3\2\17\26\2\u00ce\2\"\3\2\2\2\4%\3\2\2\2\6.\3\2")
+        buf.write("\2\2\b\66\3\2\2\2\n8\3\2\2\2\f>\3\2\2\2\16K\3\2\2\2\20")
+        buf.write("a\3\2\2\2\22e\3\2\2\2\24g\3\2\2\2\26\u0082\3\2\2\2\30")
+        buf.write("\u008d\3\2\2\2\32\u0091\3\2\2\2\34\u009d\3\2\2\2\36\u00ad")
+        buf.write("\3\2\2\2 \u00b2\3\2\2\2\"#\5\6\4\2#$\7\2\2\3$\3\3\2\2")
+        buf.write("\2%&\5\b\5\2&\'\7\2\2\3\'\5\3\2\2\2(/\5\22\n\2)/\7\3\2")
+        buf.write("\2*/\7\25\2\2+/\7\4\2\2,/\7\5\2\2-/\7\33\2\2.(\3\2\2\2")
+        buf.write(".)\3\2\2\2.*\3\2\2\2.+\3\2\2\2.,\3\2\2\2.-\3\2\2\2/\60")
+        buf.write("\3\2\2\2\60.\3\2\2\2\60\61\3\2\2\2\61\7\3\2\2\2\62\67")
+        buf.write("\5\36\20\2\63\67\5\34\17\2\64\67\5\n\6\2\65\67\5\f\7\2")
+        buf.write("\66\62\3\2\2\2\66\63\3\2\2\2\66\64\3\2\2\2\66\65\3\2\2")
+        buf.write("\2\67\t\3\2\2\28:\7\f\2\29;\5\20\t\2:9\3\2\2\2:;\3\2\2")
+        buf.write("\2;<\3\2\2\2<=\7\r\2\2=\13\3\2\2\2>G\7\7\2\2?D\5\16\b")
+        buf.write("\2@A\7\13\2\2AC\5\16\b\2B@\3\2\2\2CF\3\2\2\2DB\3\2\2\2")
+        buf.write("DE\3\2\2\2EH\3\2\2\2FD\3\2\2\2G?\3\2\2\2GH\3\2\2\2HI\3")
+        buf.write("\2\2\2IJ\7\b\2\2J\r\3\2\2\2KL\5 \21\2LM\7\16\2\2MN\5\b")
+        buf.write("\5\2N\17\3\2\2\2OV\5\b\5\2PR\7\13\2\2QS\5\b\5\2RQ\3\2")
+        buf.write("\2\2RS\3\2\2\2SU\3\2\2\2TP\3\2\2\2UX\3\2\2\2VT\3\2\2\2")
+        buf.write("VW\3\2\2\2Wb\3\2\2\2XV\3\2\2\2Y[\7\13\2\2Z\\\5\b\5\2[")
+        buf.write("Z\3\2\2\2[\\\3\2\2\2\\^\3\2\2\2]Y\3\2\2\2^_\3\2\2\2_]")
+        buf.write("\3\2\2\2_`\3\2\2\2`b\3\2\2\2aO\3\2\2\2a]\3\2\2\2b\21\3")
+        buf.write("\2\2\2cf\5\24\13\2df\5\26\f\2ec\3\2\2\2ed\3\2\2\2f\23")
+        buf.write("\3\2\2\2gk\7\6\2\2hj\7\30\2\2ih\3\2\2\2jm\3\2\2\2ki\3")
+        buf.write("\2\2\2kl\3\2\2\2ls\3\2\2\2mk\3\2\2\2nt\5\30\r\2op\7\f")
+        buf.write("\2\2pq\5\30\r\2qr\7\r\2\2rt\3\2\2\2sn\3\2\2\2so\3\2\2")
+        buf.write("\2t}\3\2\2\2uv\7\30\2\2v|\5\30\r\2wx\7\f\2\2xy\5\30\r")
+        buf.write("\2yz\7\r\2\2z|\3\2\2\2{u\3\2\2\2{w\3\2\2\2|\177\3\2\2")
+        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2\u0080")
+        buf.write("\u0081\7\27\2\2\u0081\25\3\2\2\2\u0082\u0083\7\6\2\2\u0083")
+        buf.write("\u0084\5\32\16\2\u0084\u0086\7\16\2\2\u0085\u0087\5\20")
+        buf.write("\t\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088")
+        buf.write("\3\2\2\2\u0088\u0089\7\b\2\2\u0089\27\3\2\2\2\u008a\u008e")
+        buf.write("\5\22\n\2\u008b\u008e\7\24\2\2\u008c\u008e\7\31\2\2\u008d")
+        buf.write("\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c\3\2\2\2")
+        buf.write("\u008e\31\3\2\2\2\u008f\u0092\5\22\n\2\u0090\u0092\7\24")
+        buf.write("\2\2\u0091\u008f\3\2\2\2\u0091\u0090\3\2\2\2\u0092\u009a")
+        buf.write("\3\2\2\2\u0093\u0096\7\30\2\2\u0094\u0097\5\22\n\2\u0095")
+        buf.write("\u0097\7\24\2\2\u0096\u0094\3\2\2\2\u0096\u0095\3\2\2")
+        buf.write("\2\u0097\u0099\3\2\2\2\u0098\u0093\3\2\2\2\u0099\u009c")
+        buf.write("\3\2\2\2\u009a\u0098\3\2\2\2\u009a\u009b\3\2\2\2\u009b")
+        buf.write("\33\3\2\2\2\u009c\u009a\3\2\2\2\u009d\u009f\t\2\2\2\u009e")
+        buf.write("\u00a0\5\6\4\2\u009f\u009e\3\2\2\2\u009f\u00a0\3\2\2\2")
+        buf.write("\u00a0\u00a1\3\2\2\2\u00a1\u00a2\7\32\2\2\u00a2\35\3\2")
+        buf.write("\2\2\u00a3\u00ae\7\24\2\2\u00a4\u00ae\7\22\2\2\u00a5\u00ae")
+        buf.write("\7\20\2\2\u00a6\u00ae\7\17\2\2\u00a7\u00ae\7\21\2\2\u00a8")
+        buf.write("\u00ae\7\23\2\2\u00a9\u00ae\7\16\2\2\u00aa\u00ae\7\25")
+        buf.write("\2\2\u00ab\u00ae\7\26\2\2\u00ac\u00ae\5\22\n\2\u00ad\u00a3")
+        buf.write("\3\2\2\2\u00ad\u00a4\3\2\2\2\u00ad\u00a5\3\2\2\2\u00ad")
+        buf.write("\u00a6\3\2\2\2\u00ad\u00a7\3\2\2\2\u00ad\u00a8\3\2\2\2")
+        buf.write("\u00ad\u00a9\3\2\2\2\u00ad\u00aa\3\2\2\2\u00ad\u00ab\3")
+        buf.write("\2\2\2\u00ad\u00ac\3\2\2\2\u00ae\u00af\3\2\2\2\u00af\u00ad")
+        buf.write("\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\37\3\2\2\2\u00b1\u00b3")
+        buf.write("\t\3\2\2\u00b2\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4")
+        buf.write("\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5!\3\2\2\2\33.")
+        buf.write("\60\66:DGRV[_aeks{}\u0086\u008d\u0091\u0096\u009a\u009f")
+        buf.write("\u00ad\u00af\u00b4")
+        return buf.getvalue()
+
+
+class OmegaConfGrammarParser ( Parser ):
+
+    grammarFileName = "OmegaConfGrammarParser.g4"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'.'", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'['", "']'" ]
+
+    symbolicNames = [ "<INVALID>", "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", 
+                      "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", 
+                      "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", 
+                      "COLON", "FLOAT", "INT", "BOOL", "NULL", "UNQUOTED_CHAR", 
+                      "ID", "ESC", "WS", "INTER_CLOSE", "DOT", "INTER_KEY", 
+                      "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", "INTER_BRACKET_OPEN", 
+                      "INTER_BRACKET_CLOSE" ]
+
+    RULE_configValue = 0
+    RULE_singleElement = 1
+    RULE_text = 2
+    RULE_element = 3
+    RULE_listContainer = 4
+    RULE_dictContainer = 5
+    RULE_dictKeyValuePair = 6
+    RULE_sequence = 7
+    RULE_interpolation = 8
+    RULE_interpolationNode = 9
+    RULE_interpolationResolver = 10
+    RULE_configKey = 11
+    RULE_resolverName = 12
+    RULE_quotedValue = 13
+    RULE_primitive = 14
+    RULE_dictKey = 15
+
+    ruleNames =  [ "configValue", "singleElement", "text", "element", "listContainer", 
+                   "dictContainer", "dictKeyValuePair", "sequence", "interpolation", 
+                   "interpolationNode", "interpolationResolver", "configKey", 
+                   "resolverName", "quotedValue", "primitive", "dictKey" ]
+
+    EOF = Token.EOF
+    ANY_STR=1
+    ESC_INTER=2
+    TOP_ESC=3
+    INTER_OPEN=4
+    BRACE_OPEN=5
+    BRACE_CLOSE=6
+    QUOTE_OPEN_SINGLE=7
+    QUOTE_OPEN_DOUBLE=8
+    COMMA=9
+    BRACKET_OPEN=10
+    BRACKET_CLOSE=11
+    COLON=12
+    FLOAT=13
+    INT=14
+    BOOL=15
+    NULL=16
+    UNQUOTED_CHAR=17
+    ID=18
+    ESC=19
+    WS=20
+    INTER_CLOSE=21
+    DOT=22
+    INTER_KEY=23
+    MATCHING_QUOTE_CLOSE=24
+    QUOTED_ESC=25
+    DOLLAR=26
+    INTER_BRACKET_OPEN=27
+    INTER_BRACKET_CLOSE=28
+
+    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.9.3")
+        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+        self._predicates = None
+
+
+
+
+    class ConfigValueContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def text(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0)
+
+
+        def EOF(self):
+            return self.getToken(OmegaConfGrammarParser.EOF, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_configValue
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConfigValue" ):
+                listener.enterConfigValue(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConfigValue" ):
+                listener.exitConfigValue(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConfigValue" ):
+                return visitor.visitConfigValue(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def configValue(self):
+
+        localctx = OmegaConfGrammarParser.ConfigValueContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_configValue)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 32
+            self.text()
+            self.state = 33
+            self.match(OmegaConfGrammarParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SingleElementContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def element(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0)
+
+
+        def EOF(self):
+            return self.getToken(OmegaConfGrammarParser.EOF, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_singleElement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSingleElement" ):
+                listener.enterSingleElement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSingleElement" ):
+                listener.exitSingleElement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSingleElement" ):
+                return visitor.visitSingleElement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def singleElement(self):
+
+        localctx = OmegaConfGrammarParser.SingleElementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 2, self.RULE_singleElement)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 35
+            self.element()
+            self.state = 36
+            self.match(OmegaConfGrammarParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class TextContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def ANY_STR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ANY_STR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ANY_STR, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def ESC_INTER(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC_INTER)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC_INTER, i)
+
+        def TOP_ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.TOP_ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.TOP_ESC, i)
+
+        def QUOTED_ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.QUOTED_ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.QUOTED_ESC, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_text
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterText" ):
+                listener.enterText(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitText" ):
+                listener.exitText(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitText" ):
+                return visitor.visitText(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def text(self):
+
+        localctx = OmegaConfGrammarParser.TextContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 4, self.RULE_text)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 44 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 44
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 38
+                    self.interpolation()
+                    pass
+                elif token in [OmegaConfGrammarParser.ANY_STR]:
+                    self.state = 39
+                    self.match(OmegaConfGrammarParser.ANY_STR)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC]:
+                    self.state = 40
+                    self.match(OmegaConfGrammarParser.ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC_INTER]:
+                    self.state = 41
+                    self.match(OmegaConfGrammarParser.ESC_INTER)
+                    pass
+                elif token in [OmegaConfGrammarParser.TOP_ESC]:
+                    self.state = 42
+                    self.match(OmegaConfGrammarParser.TOP_ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.QUOTED_ESC]:
+                    self.state = 43
+                    self.match(OmegaConfGrammarParser.QUOTED_ESC)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 46 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ElementContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def primitive(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.PrimitiveContext,0)
+
+
+        def quotedValue(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.QuotedValueContext,0)
+
+
+        def listContainer(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ListContainerContext,0)
+
+
+        def dictContainer(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.DictContainerContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_element
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterElement" ):
+                listener.enterElement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitElement" ):
+                listener.exitElement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitElement" ):
+                return visitor.visitElement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def element(self):
+
+        localctx = OmegaConfGrammarParser.ElementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 6, self.RULE_element)
+        try:
+            self.state = 52
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 48
+                self.primitive()
+                pass
+            elif token in [OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 49
+                self.quotedValue()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 50
+                self.listContainer()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACE_OPEN]:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 51
+                self.dictContainer()
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ListContainerContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def BRACKET_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, 0)
+
+        def BRACKET_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, 0)
+
+        def sequence(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_listContainer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterListContainer" ):
+                listener.enterListContainer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitListContainer" ):
+                listener.exitListContainer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitListContainer" ):
+                return visitor.visitListContainer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def listContainer(self):
+
+        localctx = OmegaConfGrammarParser.ListContainerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 8, self.RULE_listContainer)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 54
+            self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+            self.state = 56
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 55
+                self.sequence()
+
+
+            self.state = 58
+            self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictContainerContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def BRACE_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_OPEN, 0)
+
+        def BRACE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0)
+
+        def dictKeyValuePair(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.DictKeyValuePairContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyValuePairContext,i)
+
+
+        def COMMA(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COMMA)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COMMA, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictContainer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictContainer" ):
+                listener.enterDictContainer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictContainer" ):
+                listener.exitDictContainer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictContainer" ):
+                return visitor.visitDictContainer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictContainer(self):
+
+        localctx = OmegaConfGrammarParser.DictContainerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 10, self.RULE_dictContainer)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 60
+            self.match(OmegaConfGrammarParser.BRACE_OPEN)
+            self.state = 69
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 61
+                self.dictKeyValuePair()
+                self.state = 66
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==OmegaConfGrammarParser.COMMA:
+                    self.state = 62
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 63
+                    self.dictKeyValuePair()
+                    self.state = 68
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+
+
+            self.state = 71
+            self.match(OmegaConfGrammarParser.BRACE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictKeyValuePairContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def dictKey(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyContext,0)
+
+
+        def COLON(self):
+            return self.getToken(OmegaConfGrammarParser.COLON, 0)
+
+        def element(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictKeyValuePair
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictKeyValuePair" ):
+                listener.enterDictKeyValuePair(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictKeyValuePair" ):
+                listener.exitDictKeyValuePair(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictKeyValuePair" ):
+                return visitor.visitDictKeyValuePair(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictKeyValuePair(self):
+
+        localctx = OmegaConfGrammarParser.DictKeyValuePairContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 12, self.RULE_dictKeyValuePair)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 73
+            self.dictKey()
+            self.state = 74
+            self.match(OmegaConfGrammarParser.COLON)
+            self.state = 75
+            self.element()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SequenceContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def element(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.ElementContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,i)
+
+
+        def COMMA(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COMMA)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COMMA, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_sequence
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSequence" ):
+                listener.enterSequence(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSequence" ):
+                listener.exitSequence(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSequence" ):
+                return visitor.visitSequence(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def sequence(self):
+
+        localctx = OmegaConfGrammarParser.SequenceContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 14, self.RULE_sequence)
+        self._la = 0 # Token type
+        try:
+            self.state = 95
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.BRACE_OPEN, OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, OmegaConfGrammarParser.BRACKET_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 77
+                self.element()
+                self.state = 84
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==OmegaConfGrammarParser.COMMA:
+                    self.state = 78
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 80
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                        self.state = 79
+                        self.element()
+
+
+                    self.state = 86
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                pass
+            elif token in [OmegaConfGrammarParser.COMMA]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 91 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 87
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 89
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                        self.state = 88
+                        self.element()
+
+
+                    self.state = 93 
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if not (_la==OmegaConfGrammarParser.COMMA):
+                        break
+
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolationNode(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationNodeContext,0)
+
+
+        def interpolationResolver(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationResolverContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolation
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolation" ):
+                listener.enterInterpolation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolation" ):
+                listener.exitInterpolation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolation" ):
+                return visitor.visitInterpolation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolation(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 16, self.RULE_interpolation)
+        try:
+            self.state = 99
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 97
+                self.interpolationNode()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 98
+                self.interpolationResolver()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationNodeContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def INTER_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0)
+
+        def INTER_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_CLOSE, 0)
+
+        def configKey(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.ConfigKeyContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.ConfigKeyContext,i)
+
+
+        def BRACKET_OPEN(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BRACKET_OPEN)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, i)
+
+        def BRACKET_CLOSE(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BRACKET_CLOSE)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, i)
+
+        def DOT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.DOT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.DOT, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolationNode
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolationNode" ):
+                listener.enterInterpolationNode(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolationNode" ):
+                listener.exitInterpolationNode(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolationNode" ):
+                return visitor.visitInterpolationNode(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolationNode(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationNodeContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 18, self.RULE_interpolationNode)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 101
+            self.match(OmegaConfGrammarParser.INTER_OPEN)
+            self.state = 105
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.DOT:
+                self.state = 102
+                self.match(OmegaConfGrammarParser.DOT)
+                self.state = 107
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 113
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.INTER_KEY]:
+                self.state = 108
+                self.configKey()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                self.state = 109
+                self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+                self.state = 110
+                self.configKey()
+                self.state = 111
+                self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self.state = 123
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.BRACKET_OPEN or _la==OmegaConfGrammarParser.DOT:
+                self.state = 121
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.DOT]:
+                    self.state = 115
+                    self.match(OmegaConfGrammarParser.DOT)
+                    self.state = 116
+                    self.configKey()
+                    pass
+                elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                    self.state = 117
+                    self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+                    self.state = 118
+                    self.configKey()
+                    self.state = 119
+                    self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 125
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 126
+            self.match(OmegaConfGrammarParser.INTER_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationResolverContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def INTER_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0)
+
+        def resolverName(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ResolverNameContext,0)
+
+
+        def COLON(self):
+            return self.getToken(OmegaConfGrammarParser.COLON, 0)
+
+        def BRACE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0)
+
+        def sequence(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolationResolver
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolationResolver" ):
+                listener.enterInterpolationResolver(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolationResolver" ):
+                listener.exitInterpolationResolver(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolationResolver" ):
+                return visitor.visitInterpolationResolver(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolationResolver(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationResolverContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 20, self.RULE_interpolationResolver)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 128
+            self.match(OmegaConfGrammarParser.INTER_OPEN)
+            self.state = 129
+            self.resolverName()
+            self.state = 130
+            self.match(OmegaConfGrammarParser.COLON)
+            self.state = 132
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 131
+                self.sequence()
+
+
+            self.state = 134
+            self.match(OmegaConfGrammarParser.BRACE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ConfigKeyContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,0)
+
+
+        def ID(self):
+            return self.getToken(OmegaConfGrammarParser.ID, 0)
+
+        def INTER_KEY(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_KEY, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_configKey
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConfigKey" ):
+                listener.enterConfigKey(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConfigKey" ):
+                listener.exitConfigKey(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConfigKey" ):
+                return visitor.visitConfigKey(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def configKey(self):
+
+        localctx = OmegaConfGrammarParser.ConfigKeyContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 22, self.RULE_configKey)
+        try:
+            self.state = 139
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 136
+                self.interpolation()
+                pass
+            elif token in [OmegaConfGrammarParser.ID]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 137
+                self.match(OmegaConfGrammarParser.ID)
+                pass
+            elif token in [OmegaConfGrammarParser.INTER_KEY]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 138
+                self.match(OmegaConfGrammarParser.INTER_KEY)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ResolverNameContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def DOT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.DOT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.DOT, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_resolverName
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterResolverName" ):
+                listener.enterResolverName(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitResolverName" ):
+                listener.exitResolverName(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitResolverName" ):
+                return visitor.visitResolverName(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def resolverName(self):
+
+        localctx = OmegaConfGrammarParser.ResolverNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 24, self.RULE_resolverName)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 143
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                self.state = 141
+                self.interpolation()
+                pass
+            elif token in [OmegaConfGrammarParser.ID]:
+                self.state = 142
+                self.match(OmegaConfGrammarParser.ID)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self.state = 152
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.DOT:
+                self.state = 145
+                self.match(OmegaConfGrammarParser.DOT)
+                self.state = 148
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 146
+                    self.interpolation()
+                    pass
+                elif token in [OmegaConfGrammarParser.ID]:
+                    self.state = 147
+                    self.match(OmegaConfGrammarParser.ID)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 154
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class QuotedValueContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def MATCHING_QUOTE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE, 0)
+
+        def QUOTE_OPEN_SINGLE(self):
+            return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, 0)
+
+        def QUOTE_OPEN_DOUBLE(self):
+            return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, 0)
+
+        def text(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_quotedValue
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterQuotedValue" ):
+                listener.enterQuotedValue(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitQuotedValue" ):
+                listener.exitQuotedValue(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitQuotedValue" ):
+                return visitor.visitQuotedValue(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def quotedValue(self):
+
+        localctx = OmegaConfGrammarParser.QuotedValueContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_quotedValue)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 155
+            _la = self._input.LA(1)
+            if not(_la==OmegaConfGrammarParser.QUOTE_OPEN_SINGLE or _la==OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+            self.state = 157
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0):
+                self.state = 156
+                self.text()
+
+
+            self.state = 159
+            self.match(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class PrimitiveContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def NULL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.NULL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.NULL, i)
+
+        def INT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.INT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.INT, i)
+
+        def FLOAT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.FLOAT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.FLOAT, i)
+
+        def BOOL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BOOL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BOOL, i)
+
+        def UNQUOTED_CHAR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i)
+
+        def COLON(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COLON)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COLON, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.WS)
+            else:
+                return self.getToken(OmegaConfGrammarParser.WS, i)
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_primitive
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrimitive" ):
+                listener.enterPrimitive(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrimitive" ):
+                listener.exitPrimitive(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPrimitive" ):
+                return visitor.visitPrimitive(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def primitive(self):
+
+        localctx = OmegaConfGrammarParser.PrimitiveContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 28, self.RULE_primitive)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 171 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 171
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.ID]:
+                    self.state = 161
+                    self.match(OmegaConfGrammarParser.ID)
+                    pass
+                elif token in [OmegaConfGrammarParser.NULL]:
+                    self.state = 162
+                    self.match(OmegaConfGrammarParser.NULL)
+                    pass
+                elif token in [OmegaConfGrammarParser.INT]:
+                    self.state = 163
+                    self.match(OmegaConfGrammarParser.INT)
+                    pass
+                elif token in [OmegaConfGrammarParser.FLOAT]:
+                    self.state = 164
+                    self.match(OmegaConfGrammarParser.FLOAT)
+                    pass
+                elif token in [OmegaConfGrammarParser.BOOL]:
+                    self.state = 165
+                    self.match(OmegaConfGrammarParser.BOOL)
+                    pass
+                elif token in [OmegaConfGrammarParser.UNQUOTED_CHAR]:
+                    self.state = 166
+                    self.match(OmegaConfGrammarParser.UNQUOTED_CHAR)
+                    pass
+                elif token in [OmegaConfGrammarParser.COLON]:
+                    self.state = 167
+                    self.match(OmegaConfGrammarParser.COLON)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC]:
+                    self.state = 168
+                    self.match(OmegaConfGrammarParser.ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.WS]:
+                    self.state = 169
+                    self.match(OmegaConfGrammarParser.WS)
+                    pass
+                elif token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 170
+                    self.interpolation()
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 173 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictKeyContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def NULL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.NULL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.NULL, i)
+
+        def INT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.INT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.INT, i)
+
+        def FLOAT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.FLOAT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.FLOAT, i)
+
+        def BOOL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BOOL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BOOL, i)
+
+        def UNQUOTED_CHAR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.WS)
+            else:
+                return self.getToken(OmegaConfGrammarParser.WS, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictKey
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictKey" ):
+                listener.enterDictKey(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictKey" ):
+                listener.exitDictKey(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictKey" ):
+                return visitor.visitDictKey(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictKey(self):
+
+        localctx = OmegaConfGrammarParser.DictKeyContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 30, self.RULE_dictKey)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 176 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 175
+                _la = self._input.LA(1)
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self._errHandler.reportMatch(self)
+                    self.consume()
+                self.state = 178 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+
+
+

lib/python3.12/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserListener.py

@@ -0,0 +1,156 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .OmegaConfGrammarParser import OmegaConfGrammarParser
+else:
+    from OmegaConfGrammarParser import OmegaConfGrammarParser
+
+# This class defines a complete listener for a parse tree produced by OmegaConfGrammarParser.
+class OmegaConfGrammarParserListener(ParseTreeListener):
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#configValue.
+    def enterConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#configValue.
+    def exitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def enterSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def exitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#text.
+    def enterText(self, ctx:OmegaConfGrammarParser.TextContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#text.
+    def exitText(self, ctx:OmegaConfGrammarParser.TextContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#element.
+    def enterElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#element.
+    def exitElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def enterListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def exitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def enterDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def exitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def enterDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def exitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#sequence.
+    def enterSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#sequence.
+    def exitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def enterInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def exitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def enterInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def exitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def enterInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def exitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#configKey.
+    def enterConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#configKey.
+    def exitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def enterResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def exitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def enterQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def exitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#primitive.
+    def enterPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#primitive.
+    def exitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def enterDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def exitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        pass
+
+
+
+del OmegaConfGrammarParser

lib/python3.12/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserVisitor.py

@@ -0,0 +1,93 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .OmegaConfGrammarParser import OmegaConfGrammarParser
+else:
+    from OmegaConfGrammarParser import OmegaConfGrammarParser
+
+# This class defines a complete generic visitor for a parse tree produced by OmegaConfGrammarParser.
+
+class OmegaConfGrammarParserVisitor(ParseTreeVisitor):
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#configValue.
+    def visitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def visitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#text.
+    def visitText(self, ctx:OmegaConfGrammarParser.TextContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#element.
+    def visitElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def visitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def visitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def visitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#sequence.
+    def visitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def visitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def visitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def visitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#configKey.
+    def visitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def visitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def visitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#primitive.
+    def visitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def visitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        return self.visitChildren(ctx)
+
+
+
+del OmegaConfGrammarParser

lib/python3.12/site-packages/omegaconf/grammar_parser.py

@@ -0,0 +1,144 @@
+import re
+import threading
+from typing import Any
+
+from antlr4 import CommonTokenStream, InputStream, ParserRuleContext
+from antlr4.error.ErrorListener import ErrorListener
+
+from .errors import GrammarParseError
+
+# Import from visitor in order to check the presence of generated grammar files
+# files in a single place.
+from .grammar_visitor import (  # type: ignore
+    OmegaConfGrammarLexer,
+    OmegaConfGrammarParser,
+)
+
+# Used to cache grammar objects to avoid re-creating them on each call to `parse()`.
+# We use a per-thread cache to make it thread-safe.
+_grammar_cache = threading.local()
+
+# Build regex pattern to efficiently identify typical interpolations.
+# See test `test_match_simple_interpolation_pattern` for examples.
+_config_key = r"[$\w]+"  # foo, $0, $bar, $foo_$bar123$
+_key_maybe_brackets = f"{_config_key}|\\[{_config_key}\\]"  # foo, [foo], [$bar]
+_node_access = f"\\.{_key_maybe_brackets}"  # .foo, [foo], [$bar]
+_node_path = f"(\\.)*({_key_maybe_brackets})({_node_access})*"  # [foo].bar, .foo[bar]
+_node_inter = f"\\${{\\s*{_node_path}\\s*}}"  # node interpolation ${foo.bar}
+_id = "[a-zA-Z_][\\w\\-]*"  # foo, foo_bar, foo-bar, abc123
+_resolver_name = f"({_id}(\\.{_id})*)?"  # foo, ns.bar3, ns_1.ns_2.b0z
+_arg = r"[a-zA-Z_0-9/\-\+.$%*@?|]+"  # string representing a resolver argument
+_args = f"{_arg}(\\s*,\\s*{_arg})*"  # list of resolver arguments
+_resolver_inter = f"\\${{\\s*{_resolver_name}\\s*:\\s*{_args}?\\s*}}"  # ${foo:bar}
+_inter = f"({_node_inter}|{_resolver_inter})"  # any kind of interpolation
+_outer = "([^$]|\\$(?!{))+"  # any character except $ (unless not followed by {)
+SIMPLE_INTERPOLATION_PATTERN = re.compile(
+    f"({_outer})?({_inter}({_outer})?)+$", flags=re.ASCII
+)
+# NOTE: SIMPLE_INTERPOLATION_PATTERN must not generate false positive matches:
+# it must not accept anything that isn't a valid interpolation (per the
+# interpolation grammar defined in `omegaconf/grammar/*.g4`).
+
+
+class OmegaConfErrorListener(ErrorListener):  # type: ignore
+    def syntaxError(
+        self,
+        recognizer: Any,
+        offending_symbol: Any,
+        line: Any,
+        column: Any,
+        msg: Any,
+        e: Any,
+    ) -> None:
+        raise GrammarParseError(str(e) if msg is None else msg) from e
+
+    def reportAmbiguity(
+        self,
+        recognizer: Any,
+        dfa: Any,
+        startIndex: Any,
+        stopIndex: Any,
+        exact: Any,
+        ambigAlts: Any,
+        configs: Any,
+    ) -> None:
+        raise GrammarParseError("ANTLR error: Ambiguity")  # pragma: no cover
+
+    def reportAttemptingFullContext(
+        self,
+        recognizer: Any,
+        dfa: Any,
+        startIndex: Any,
+        stopIndex: Any,
+        conflictingAlts: Any,
+        configs: Any,
+    ) -> None:
+        # Note: for now we raise an error to be safe. However this is mostly a
+        # performance warning, so in the future this may be relaxed if we need
+        # to change the grammar in such a way that this warning cannot be
+        # avoided (another option would be to switch to SLL parsing mode).
+        raise GrammarParseError(
+            "ANTLR error: Attempting Full Context"
+        )  # pragma: no cover
+
+    def reportContextSensitivity(
+        self,
+        recognizer: Any,
+        dfa: Any,
+        startIndex: Any,
+        stopIndex: Any,
+        prediction: Any,
+        configs: Any,
+    ) -> None:
+        raise GrammarParseError("ANTLR error: ContextSensitivity")  # pragma: no cover
+
+
+def parse(
+    value: str, parser_rule: str = "configValue", lexer_mode: str = "DEFAULT_MODE"
+) -> ParserRuleContext:
+    """
+    Parse interpolated string `value` (and return the parse tree).
+    """
+    l_mode = getattr(OmegaConfGrammarLexer, lexer_mode)
+    istream = InputStream(value)
+
+    cached = getattr(_grammar_cache, "data", None)
+    if cached is None:
+        error_listener = OmegaConfErrorListener()
+        lexer = OmegaConfGrammarLexer(istream)
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(error_listener)
+        lexer.mode(l_mode)
+        token_stream = CommonTokenStream(lexer)
+        parser = OmegaConfGrammarParser(token_stream)
+        parser.removeErrorListeners()
+        parser.addErrorListener(error_listener)
+
+        # The two lines below could be enabled in the future if we decide to switch
+        # to SLL prediction mode. Warning though, it has not been fully tested yet!
+        # from antlr4 import PredictionMode
+        # parser._interp.predictionMode = PredictionMode.SLL
+
+        # Note that although the input stream `istream` is implicitly cached within
+        # the lexer, it will be replaced by a new input next time the lexer is re-used.
+        _grammar_cache.data = lexer, token_stream, parser
+
+    else:
+        lexer, token_stream, parser = cached
+        # Replace the old input stream with the new one.
+        lexer.inputStream = istream
+        # Initialize the lexer / token stream / parser to process the new input.
+        lexer.mode(l_mode)
+        token_stream.setTokenSource(lexer)
+        parser.reset()
+
+    try:
+        return getattr(parser, parser_rule)()
+    except Exception as exc:
+        if type(exc) is Exception and str(exc) == "Empty Stack":
+            # This exception is raised by antlr when trying to pop a mode while
+            # no mode has been pushed. We convert it into an `GrammarParseError`
+            # to facilitate exception handling from the caller.
+            raise GrammarParseError("Empty Stack")
+        else:
+            raise

lib/python3.12/site-packages/omegaconf/grammar_visitor.py

@@ -0,0 +1,392 @@
+import sys
+import warnings
+from itertools import zip_longest
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+from antlr4 import TerminalNode
+
+from .errors import InterpolationResolutionError
+
+if TYPE_CHECKING:
+    from .base import Node  # noqa F401
+
+try:
+    from omegaconf.grammar.gen.OmegaConfGrammarLexer import OmegaConfGrammarLexer
+    from omegaconf.grammar.gen.OmegaConfGrammarParser import OmegaConfGrammarParser
+    from omegaconf.grammar.gen.OmegaConfGrammarParserVisitor import (
+        OmegaConfGrammarParserVisitor,
+    )
+
+except ModuleNotFoundError:  # pragma: no cover
+    print(
+        "Error importing OmegaConf's generated parsers, run `python setup.py antlr` to regenerate.",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+
+class GrammarVisitor(OmegaConfGrammarParserVisitor):
+    def __init__(
+        self,
+        node_interpolation_callback: Callable[
+            [str, Optional[Set[int]]],
+            Optional["Node"],
+        ],
+        resolver_interpolation_callback: Callable[..., Any],
+        memo: Optional[Set[int]],
+        **kw: Dict[Any, Any],
+    ):
+        """
+        Constructor.
+
+        :param node_interpolation_callback: Callback function that is called when
+            needing to resolve a node interpolation. This function should take a single
+            string input which is the key's dot path (ex: `"foo.bar"`).
+
+        :param resolver_interpolation_callback: Callback function that is called when
+            needing to resolve a resolver interpolation. This function should accept
+            three keyword arguments: `name` (str, the name of the resolver),
+            `args` (tuple, the inputs to the resolver), and `args_str` (tuple,
+            the string representation of the inputs to the resolver).
+
+        :param kw: Additional keyword arguments to be forwarded to parent class.
+        """
+        super().__init__(**kw)
+        self.node_interpolation_callback = node_interpolation_callback
+        self.resolver_interpolation_callback = resolver_interpolation_callback
+        self.memo = memo
+
+    def aggregateResult(self, aggregate: List[Any], nextResult: Any) -> List[Any]:
+        raise NotImplementedError
+
+    def defaultResult(self) -> List[Any]:
+        # Raising an exception because not currently used (like `aggregateResult()`).
+        raise NotImplementedError
+
+    def visitConfigKey(self, ctx: OmegaConfGrammarParser.ConfigKeyContext) -> str:
+        from ._utils import _get_value
+
+        # interpolation | ID | INTER_KEY
+        assert ctx.getChildCount() == 1
+        child = ctx.getChild(0)
+        if isinstance(child, OmegaConfGrammarParser.InterpolationContext):
+            res = _get_value(self.visitInterpolation(child))
+            if not isinstance(res, str):
+                raise InterpolationResolutionError(
+                    f"The following interpolation is used to denote a config key and "
+                    f"thus should return a string, but instead returned `{res}` of "
+                    f"type `{type(res)}`: {ctx.getChild(0).getText()}"
+                )
+            return res
+        else:
+            assert isinstance(child, TerminalNode) and isinstance(
+                child.symbol.text, str
+            )
+            return child.symbol.text
+
+    def visitConfigValue(self, ctx: OmegaConfGrammarParser.ConfigValueContext) -> Any:
+        # text EOF
+        assert ctx.getChildCount() == 2
+        return self.visit(ctx.getChild(0))
+
+    def visitDictKey(self, ctx: OmegaConfGrammarParser.DictKeyContext) -> Any:
+        return self._createPrimitive(ctx)
+
+    def visitDictContainer(
+        self, ctx: OmegaConfGrammarParser.DictContainerContext
+    ) -> Dict[Any, Any]:
+        # BRACE_OPEN (dictKeyValuePair (COMMA dictKeyValuePair)*)? BRACE_CLOSE
+        assert ctx.getChildCount() >= 2
+        return dict(
+            self.visitDictKeyValuePair(ctx.getChild(i))
+            for i in range(1, ctx.getChildCount() - 1, 2)
+        )
+
+    def visitElement(self, ctx: OmegaConfGrammarParser.ElementContext) -> Any:
+        # primitive | quotedValue | listContainer | dictContainer
+        assert ctx.getChildCount() == 1
+        return self.visit(ctx.getChild(0))
+
+    def visitInterpolation(
+        self, ctx: OmegaConfGrammarParser.InterpolationContext
+    ) -> Any:
+        assert ctx.getChildCount() == 1  # interpolationNode | interpolationResolver
+        return self.visit(ctx.getChild(0))
+
+    def visitInterpolationNode(
+        self, ctx: OmegaConfGrammarParser.InterpolationNodeContext
+    ) -> Optional["Node"]:
+        # INTER_OPEN
+        # DOT*                                                     // relative interpolation?
+        # (configKey | BRACKET_OPEN configKey BRACKET_CLOSE)       // foo, [foo]
+        # (DOT configKey | BRACKET_OPEN configKey BRACKET_CLOSE)*  // .foo, [foo], .foo[bar], [foo].bar[baz]
+        # INTER_CLOSE;
+
+        assert ctx.getChildCount() >= 3
+
+        inter_key_tokens = []  # parsed elements of the dot path
+        for child in ctx.getChildren():
+            if isinstance(child, TerminalNode):
+                s = child.symbol
+                if s.type in [
+                    OmegaConfGrammarLexer.DOT,
+                    OmegaConfGrammarLexer.BRACKET_OPEN,
+                    OmegaConfGrammarLexer.BRACKET_CLOSE,
+                ]:
+                    inter_key_tokens.append(s.text)
+                else:
+                    assert s.type in (
+                        OmegaConfGrammarLexer.INTER_OPEN,
+                        OmegaConfGrammarLexer.INTER_CLOSE,
+                    )
+            else:
+                assert isinstance(child, OmegaConfGrammarParser.ConfigKeyContext)
+                inter_key_tokens.append(self.visitConfigKey(child))
+
+        inter_key = "".join(inter_key_tokens)
+        return self.node_interpolation_callback(inter_key, self.memo)
+
+    def visitInterpolationResolver(
+        self, ctx: OmegaConfGrammarParser.InterpolationResolverContext
+    ) -> Any:
+
+        # INTER_OPEN resolverName COLON sequence? BRACE_CLOSE
+        assert 4 <= ctx.getChildCount() <= 5
+
+        resolver_name = self.visit(ctx.getChild(1))
+        maybe_seq = ctx.getChild(3)
+        args = []
+        args_str = []
+        if isinstance(maybe_seq, TerminalNode):  # means there are no args
+            assert maybe_seq.symbol.type == OmegaConfGrammarLexer.BRACE_CLOSE
+        else:
+            assert isinstance(maybe_seq, OmegaConfGrammarParser.SequenceContext)
+            for val, txt in self.visitSequence(maybe_seq):
+                args.append(val)
+                args_str.append(txt)
+
+        return self.resolver_interpolation_callback(
+            name=resolver_name,
+            args=tuple(args),
+            args_str=tuple(args_str),
+        )
+
+    def visitDictKeyValuePair(
+        self, ctx: OmegaConfGrammarParser.DictKeyValuePairContext
+    ) -> Tuple[Any, Any]:
+        from ._utils import _get_value
+
+        assert ctx.getChildCount() == 3  # dictKey COLON element
+        key = self.visit(ctx.getChild(0))
+        colon = ctx.getChild(1)
+        assert (
+            isinstance(colon, TerminalNode)
+            and colon.symbol.type == OmegaConfGrammarLexer.COLON
+        )
+        value = _get_value(self.visitElement(ctx.getChild(2)))
+        return key, value
+
+    def visitListContainer(
+        self, ctx: OmegaConfGrammarParser.ListContainerContext
+    ) -> List[Any]:
+        # BRACKET_OPEN sequence? BRACKET_CLOSE;
+        assert ctx.getChildCount() in (2, 3)
+        if ctx.getChildCount() == 2:
+            return []
+        sequence = ctx.getChild(1)
+        assert isinstance(sequence, OmegaConfGrammarParser.SequenceContext)
+        return list(val for val, _ in self.visitSequence(sequence))  # ignore raw text
+
+    def visitPrimitive(self, ctx: OmegaConfGrammarParser.PrimitiveContext) -> Any:
+        return self._createPrimitive(ctx)
+
+    def visitQuotedValue(self, ctx: OmegaConfGrammarParser.QuotedValueContext) -> str:
+        # (QUOTE_OPEN_SINGLE | QUOTE_OPEN_DOUBLE) text? MATCHING_QUOTE_CLOSE
+        n = ctx.getChildCount()
+        assert n in [2, 3]
+        return str(self.visit(ctx.getChild(1))) if n == 3 else ""
+
+    def visitResolverName(self, ctx: OmegaConfGrammarParser.ResolverNameContext) -> str:
+        from ._utils import _get_value
+
+        # (interpolation | ID) (DOT (interpolation | ID))*
+        assert ctx.getChildCount() >= 1
+        items = []
+        for child in list(ctx.getChildren())[::2]:
+            if isinstance(child, TerminalNode):
+                assert child.symbol.type == OmegaConfGrammarLexer.ID
+                items.append(child.symbol.text)
+            else:
+                assert isinstance(child, OmegaConfGrammarParser.InterpolationContext)
+                item = _get_value(self.visitInterpolation(child))
+                if not isinstance(item, str):
+                    raise InterpolationResolutionError(
+                        f"The name of a resolver must be a string, but the interpolation "
+                        f"{child.getText()} resolved to `{item}` which is of type "
+                        f"{type(item)}"
+                    )
+                items.append(item)
+        return ".".join(items)
+
+    def visitSequence(
+        self, ctx: OmegaConfGrammarParser.SequenceContext
+    ) -> Generator[Any, None, None]:
+        from ._utils import _get_value
+
+        # (element (COMMA element?)*) | (COMMA element?)+
+        assert ctx.getChildCount() >= 1
+
+        # DEPRECATED: remove in 2.2 (revert #571)
+        def empty_str_warning() -> None:
+            txt = ctx.getText()
+            warnings.warn(
+                f"In the sequence `{txt}` some elements are missing: please replace "
+                f"them with empty quoted strings. "
+                f"See https://github.com/omry/omegaconf/issues/572 for details.",
+                category=UserWarning,
+            )
+
+        is_previous_comma = True  # whether previous child was a comma (init to True)
+        for child in ctx.getChildren():
+            if isinstance(child, OmegaConfGrammarParser.ElementContext):
+                # Also preserve the original text representation of `child` so
+                # as to allow backward compatibility with old resolvers (registered
+                # with `legacy_register_resolver()`). Note that we cannot just cast
+                # the value to string later as for instance `null` would become "None".
+                yield _get_value(self.visitElement(child)), child.getText()
+                is_previous_comma = False
+            else:
+                assert (
+                    isinstance(child, TerminalNode)
+                    and child.symbol.type == OmegaConfGrammarLexer.COMMA
+                )
+                if is_previous_comma:
+                    empty_str_warning()
+                    yield "", ""
+                else:
+                    is_previous_comma = True
+        if is_previous_comma:
+            # Trailing comma.
+            empty_str_warning()
+            yield "", ""
+
+    def visitSingleElement(
+        self, ctx: OmegaConfGrammarParser.SingleElementContext
+    ) -> Any:
+        # element EOF
+        assert ctx.getChildCount() == 2
+        return self.visit(ctx.getChild(0))
+
+    def visitText(self, ctx: OmegaConfGrammarParser.TextContext) -> Any:
+        # (interpolation | ANY_STR | ESC | ESC_INTER | TOP_ESC | QUOTED_ESC)+
+
+        # Single interpolation? If yes, return its resolved value "as is".
+        if ctx.getChildCount() == 1:
+            c = ctx.getChild(0)
+            if isinstance(c, OmegaConfGrammarParser.InterpolationContext):
+                return self.visitInterpolation(c)
+
+        # Otherwise, concatenate string representations together.
+        return self._unescape(list(ctx.getChildren()))
+
+    def _createPrimitive(
+        self,
+        ctx: Union[
+            OmegaConfGrammarParser.PrimitiveContext,
+            OmegaConfGrammarParser.DictKeyContext,
+        ],
+    ) -> Any:
+        # (ID | NULL | INT | FLOAT | BOOL | UNQUOTED_CHAR | COLON | ESC | WS | interpolation)+
+        if ctx.getChildCount() == 1:
+            child = ctx.getChild(0)
+            if isinstance(child, OmegaConfGrammarParser.InterpolationContext):
+                return self.visitInterpolation(child)
+            assert isinstance(child, TerminalNode)
+            symbol = child.symbol
+            # Parse primitive types.
+            if symbol.type in (
+                OmegaConfGrammarLexer.ID,
+                OmegaConfGrammarLexer.UNQUOTED_CHAR,
+                OmegaConfGrammarLexer.COLON,
+            ):
+                return symbol.text
+            elif symbol.type == OmegaConfGrammarLexer.NULL:
+                return None
+            elif symbol.type == OmegaConfGrammarLexer.INT:
+                return int(symbol.text)
+            elif symbol.type == OmegaConfGrammarLexer.FLOAT:
+                return float(symbol.text)
+            elif symbol.type == OmegaConfGrammarLexer.BOOL:
+                return symbol.text.lower() == "true"
+            elif symbol.type == OmegaConfGrammarLexer.ESC:
+                return self._unescape([child])
+            elif symbol.type == OmegaConfGrammarLexer.WS:  # pragma: no cover
+                # A single WS should have been "consumed" by another token.
+                raise AssertionError("WS should never be reached")
+            assert False, symbol.type
+        # Concatenation of multiple items ==> un-escape the concatenation.
+        return self._unescape(list(ctx.getChildren()))
+
+    def _unescape(
+        self,
+        seq: List[Union[TerminalNode, OmegaConfGrammarParser.InterpolationContext]],
+    ) -> str:
+        """
+        Concatenate all symbols / interpolations in `seq`, unescaping symbols as needed.
+
+        Interpolations are resolved and cast to string *WITHOUT* escaping their result
+        (it is assumed that whatever escaping is required was already handled during the
+        resolving of the interpolation).
+        """
+        chrs = []
+        for node, next_node in zip_longest(seq, seq[1:]):
+            if isinstance(node, TerminalNode):
+                s = node.symbol
+                if s.type == OmegaConfGrammarLexer.ESC_INTER:
+                    # `ESC_INTER` is of the form `\\...\${`: the formula below computes
+                    # the number of characters to keep at the end of the string to remove
+                    # the correct number of backslashes.
+                    text = s.text[-(len(s.text) // 2 + 1) :]
+                elif (
+                    # Character sequence identified as requiring un-escaping.
+                    s.type == OmegaConfGrammarLexer.ESC
+                    or (
+                        # At top level, we need to un-escape backslashes that precede
+                        # an interpolation.
+                        s.type == OmegaConfGrammarLexer.TOP_ESC
+                        and isinstance(
+                            next_node, OmegaConfGrammarParser.InterpolationContext
+                        )
+                    )
+                    or (
+                        # In a quoted sring, we need to un-escape backslashes that
+                        # either end the string, or are followed by an interpolation.
+                        s.type == OmegaConfGrammarLexer.QUOTED_ESC
+                        and (
+                            next_node is None
+                            or isinstance(
+                                next_node, OmegaConfGrammarParser.InterpolationContext
+                            )
+                        )
+                    )
+                ):
+                    text = s.text[1::2]  # un-escape the sequence
+                else:
+                    text = s.text  # keep the original text
+            else:
+                assert isinstance(node, OmegaConfGrammarParser.InterpolationContext)
+                text = str(self.visitInterpolation(node))
+            chrs.append(text)
+
+        return "".join(chrs)

lib/python3.12/site-packages/omegaconf/listconfig.py

@@ -0,0 +1,679 @@
+import copy
+import itertools
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    MutableSequence,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+
+from ._utils import (
+    ValueKind,
+    _is_missing_literal,
+    _is_none,
+    _resolve_optional,
+    format_and_raise,
+    get_value_kind,
+    is_int,
+    is_primitive_list,
+    is_structured_config,
+    type_str,
+)
+from .base import Box, ContainerMetadata, Node
+from .basecontainer import BaseContainer
+from .errors import (
+    ConfigAttributeError,
+    ConfigTypeError,
+    ConfigValueError,
+    KeyValidationError,
+    MissingMandatoryValue,
+    ReadonlyConfigError,
+    ValidationError,
+)
+
+
+class ListConfig(BaseContainer, MutableSequence[Any]):
+
+    _content: Union[List[Node], None, str]
+
+    def __init__(
+        self,
+        content: Union[List[Any], Tuple[Any, ...], "ListConfig", str, None],
+        key: Any = None,
+        parent: Optional[Box] = None,
+        element_type: Union[Type[Any], Any] = Any,
+        is_optional: bool = True,
+        ref_type: Union[Type[Any], Any] = Any,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> None:
+        try:
+            if isinstance(content, ListConfig):
+                if flags is None:
+                    flags = content._metadata.flags
+            super().__init__(
+                parent=parent,
+                metadata=ContainerMetadata(
+                    ref_type=ref_type,
+                    object_type=list,
+                    key=key,
+                    optional=is_optional,
+                    element_type=element_type,
+                    key_type=int,
+                    flags=flags,
+                ),
+            )
+
+            if isinstance(content, ListConfig):
+                metadata = copy.deepcopy(content._metadata)
+                metadata.key = key
+                metadata.ref_type = ref_type
+                metadata.optional = is_optional
+                metadata.element_type = element_type
+                self.__dict__["_metadata"] = metadata
+            self._set_value(value=content, flags=flags)
+        except Exception as ex:
+            format_and_raise(node=None, key=key, value=None, cause=ex, msg=str(ex))
+
+    def _validate_get(self, key: Any, value: Any = None) -> None:
+        if not isinstance(key, (int, slice)):
+            raise KeyValidationError(
+                "ListConfig indices must be integers or slices, not $KEY_TYPE"
+            )
+
+    def _validate_set(self, key: Any, value: Any) -> None:
+        from omegaconf import OmegaConf
+
+        self._validate_get(key, value)
+
+        if self._get_flag("readonly"):
+            raise ReadonlyConfigError("ListConfig is read-only")
+
+        if 0 <= key < self.__len__():
+            target = self._get_node(key)
+            if target is not None:
+                assert isinstance(target, Node)
+                if value is None and not target._is_optional():
+                    raise ValidationError(
+                        "$FULL_KEY is not optional and cannot be assigned None"
+                    )
+
+        vk = get_value_kind(value)
+        if vk == ValueKind.MANDATORY_MISSING:
+            return
+        else:
+            is_optional, target_type = _resolve_optional(self._metadata.element_type)
+            value_type = OmegaConf.get_type(value)
+
+            if (value_type is None and not is_optional) or (
+                is_structured_config(target_type)
+                and value_type is not None
+                and not issubclass(value_type, target_type)
+            ):
+                msg = (
+                    f"Invalid type assigned: {type_str(value_type)} is not a "
+                    f"subclass of {type_str(target_type)}. value: {value}"
+                )
+                raise ValidationError(msg)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "ListConfig":
+        res = ListConfig(None)
+        res.__dict__["_metadata"] = copy.deepcopy(self.__dict__["_metadata"], memo=memo)
+        res.__dict__["_flags_cache"] = copy.deepcopy(
+            self.__dict__["_flags_cache"], memo=memo
+        )
+
+        src_content = self.__dict__["_content"]
+        if isinstance(src_content, list):
+            content_copy: List[Optional[Node]] = []
+            for v in src_content:
+                old_parent = v.__dict__["_parent"]
+                try:
+                    v.__dict__["_parent"] = None
+                    vc = copy.deepcopy(v, memo=memo)
+                    vc.__dict__["_parent"] = res
+                    content_copy.append(vc)
+                finally:
+                    v.__dict__["_parent"] = old_parent
+        else:
+            # None and strings can be assigned as is
+            content_copy = src_content
+
+        res.__dict__["_content"] = content_copy
+        res.__dict__["_parent"] = self.__dict__["_parent"]
+
+        return res
+
+    def copy(self) -> "ListConfig":
+        return copy.copy(self)
+
+    # hide content while inspecting in debugger
+    def __dir__(self) -> Iterable[str]:
+        if self._is_missing() or self._is_none():
+            return []
+        return [str(x) for x in range(0, len(self))]
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        self._format_and_raise(
+            key=key,
+            value=value,
+            cause=ConfigAttributeError("ListConfig does not support attribute access"),
+        )
+        assert False
+
+    def __getattr__(self, key: str) -> Any:
+        # PyCharm is sometimes inspecting __members__, be sure to tell it we don't have that.
+        if key == "__members__":
+            raise AttributeError()
+
+        if key == "__name__":
+            raise AttributeError()
+
+        if is_int(key):
+            return self.__getitem__(int(key))
+        else:
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ConfigAttributeError(
+                    "ListConfig does not support attribute access"
+                ),
+            )
+
+    def __getitem__(self, index: Union[int, slice]) -> Any:
+        try:
+            if self._is_missing():
+                raise MissingMandatoryValue("ListConfig is missing")
+            self._validate_get(index, None)
+            if self._is_none():
+                raise TypeError(
+                    "ListConfig object representing None is not subscriptable"
+                )
+
+            assert isinstance(self.__dict__["_content"], list)
+            if isinstance(index, slice):
+                result = []
+                start, stop, step = self._correct_index_params(index)
+                for slice_idx in itertools.islice(
+                    range(0, len(self)), start, stop, step
+                ):
+                    val = self._resolve_with_default(
+                        key=slice_idx, value=self.__dict__["_content"][slice_idx]
+                    )
+                    result.append(val)
+                if index.step and index.step < 0:
+                    result.reverse()
+                return result
+            else:
+                return self._resolve_with_default(
+                    key=index, value=self.__dict__["_content"][index]
+                )
+        except Exception as e:
+            self._format_and_raise(key=index, value=None, cause=e)
+
+    def _correct_index_params(self, index: slice) -> Tuple[int, int, int]:
+        start = index.start
+        stop = index.stop
+        step = index.step
+        if index.start and index.start < 0:
+            start = self.__len__() + index.start
+        if index.stop and index.stop < 0:
+            stop = self.__len__() + index.stop
+        if index.step and index.step < 0:
+            step = abs(step)
+            if start and stop:
+                if start > stop:
+                    start, stop = stop + 1, start + 1
+                else:
+                    start = stop = 0
+            elif not start and stop:
+                start = list(range(self.__len__() - 1, stop, -step))[0]
+                stop = None
+            elif start and not stop:
+                stop = start + 1
+                start = (stop - 1) % step
+            else:
+                start = (self.__len__() - 1) % step
+        return start, stop, step
+
+    def _set_at_index(self, index: Union[int, slice], value: Any) -> None:
+        self._set_item_impl(index, value)
+
+    def __setitem__(self, index: Union[int, slice], value: Any) -> None:
+        try:
+            if isinstance(index, slice):
+                _ = iter(value)  # check iterable
+                self_indices = index.indices(len(self))
+                indexes = range(*self_indices)
+
+                # Ensure lengths match for extended slice assignment
+                if index.step not in (None, 1):
+                    if len(indexes) != len(value):
+                        raise ValueError(
+                            f"attempt to assign sequence of size {len(value)}"
+                            f" to extended slice of size {len(indexes)}"
+                        )
+
+                # Initialize insertion offsets for empty slices
+                if len(indexes) == 0:
+                    curr_index = self_indices[0] - 1
+                    val_i = -1
+
+                work_copy = self.copy()  # For atomicity manipulate a copy
+
+                # Delete and optionally replace non empty slices
+                only_removed = 0
+                for val_i, i in enumerate(indexes):
+                    curr_index = i - only_removed
+                    del work_copy[curr_index]
+                    if val_i < len(value):
+                        work_copy.insert(curr_index, value[val_i])
+                    else:
+                        only_removed += 1
+
+                # Insert any remaining input items
+                for val_i in range(val_i + 1, len(value)):
+                    curr_index += 1
+                    work_copy.insert(curr_index, value[val_i])
+
+                # Reinitialize self with work_copy
+                self.clear()
+                self.extend(work_copy)
+            else:
+                self._set_at_index(index, value)
+        except Exception as e:
+            self._format_and_raise(key=index, value=value, cause=e)
+
+    def append(self, item: Any) -> None:
+        content = self.__dict__["_content"]
+        index = len(content)
+        content.append(None)
+        try:
+            self._set_item_impl(index, item)
+        except Exception as e:
+            del content[index]
+            self._format_and_raise(key=index, value=item, cause=e)
+            assert False
+
+    def _update_keys(self) -> None:
+        for i in range(len(self)):
+            node = self._get_node(i)
+            if node is not None:
+                assert isinstance(node, Node)
+                node._metadata.key = i
+
+    def insert(self, index: int, item: Any) -> None:
+        from omegaconf.omegaconf import _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)
+                is_optional, ref_type = _resolve_optional(self._metadata.element_type)
+                node = _maybe_wrap(
+                    ref_type=ref_type,
+                    key=index,
+                    value=item,
+                    is_optional=is_optional,
+                    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 extend(self, lst: Iterable[Any]) -> None:
+        assert isinstance(lst, (tuple, list, ListConfig))
+        for x in lst:
+            self.append(x)
+
+    def remove(self, x: Any) -> None:
+        del self[self.index(x)]
+
+    def __delitem__(self, key: Union[int, slice]) -> None:
+        if self._get_flag("readonly"):
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ReadonlyConfigError(
+                    "Cannot delete item from read-only ListConfig"
+                ),
+            )
+        del self.__dict__["_content"][key]
+        self._update_keys()
+
+    def clear(self) -> None:
+        del self[:]
+
+    def index(
+        self, x: Any, start: Optional[int] = None, end: Optional[int] = None
+    ) -> int:
+        if start is None:
+            start = 0
+        if end is None:
+            end = len(self)
+        assert start >= 0
+        assert end <= len(self)
+        found_idx = -1
+        for idx in range(start, end):
+            item = self[idx]
+            if x == item:
+                found_idx = idx
+                break
+        if found_idx != -1:
+            return found_idx
+        else:
+            self._format_and_raise(
+                key=None,
+                value=None,
+                cause=ConfigValueError("Item not found in ListConfig"),
+            )
+            assert False
+
+    def count(self, x: Any) -> int:
+        c = 0
+        for item in self:
+            if item == x:
+                c = c + 1
+        return c
+
+    def _get_node(
+        self,
+        key: Union[int, slice],
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Union[Optional[Node], List[Optional[Node]]]:
+        try:
+            if self._is_none():
+                raise TypeError(
+                    "Cannot get_node from a ListConfig object representing None"
+                )
+            if self._is_missing():
+                raise MissingMandatoryValue("Cannot get_node from a missing ListConfig")
+            assert isinstance(self.__dict__["_content"], list)
+            if validate_access:
+                self._validate_get(key)
+
+            value = self.__dict__["_content"][key]
+            if value is not None:
+                if isinstance(key, slice):
+                    assert isinstance(value, list)
+                    for v in value:
+                        if throw_on_missing_value and v._is_missing():
+                            raise MissingMandatoryValue("Missing mandatory value")
+                else:
+                    assert isinstance(value, Node)
+                    if throw_on_missing_value and value._is_missing():
+                        raise MissingMandatoryValue("Missing mandatory value: $KEY")
+            return value
+        except (IndexError, TypeError, MissingMandatoryValue, KeyValidationError) as e:
+            if isinstance(e, MissingMandatoryValue) and throw_on_missing_value:
+                raise
+            if validate_access:
+                self._format_and_raise(key=key, value=None, cause=e)
+                assert False
+            else:
+                return None
+
+    def get(self, index: int, default_value: Any = None) -> Any:
+        try:
+            if self._is_none():
+                raise TypeError("Cannot get from a ListConfig object representing None")
+            if self._is_missing():
+                raise MissingMandatoryValue("Cannot get from a missing ListConfig")
+            self._validate_get(index, None)
+            assert isinstance(self.__dict__["_content"], list)
+            return self._resolve_with_default(
+                key=index,
+                value=self.__dict__["_content"][index],
+                default_value=default_value,
+            )
+        except Exception as e:
+            self._format_and_raise(key=index, value=None, cause=e)
+            assert False
+
+    def pop(self, index: int = -1) -> Any:
+        try:
+            if self._get_flag("readonly"):
+                raise ReadonlyConfigError("Cannot pop from read-only ListConfig")
+            if self._is_none():
+                raise TypeError("Cannot pop from a ListConfig object representing None")
+            if self._is_missing():
+                raise MissingMandatoryValue("Cannot pop from a missing ListConfig")
+
+            assert isinstance(self.__dict__["_content"], list)
+            node = self._get_child(index)
+            assert isinstance(node, Node)
+            ret = self._resolve_with_default(key=index, value=node, default_value=None)
+            del self.__dict__["_content"][index]
+            self._update_keys()
+            return ret
+        except KeyValidationError as e:
+            self._format_and_raise(
+                key=index, value=None, cause=e, type_override=ConfigTypeError
+            )
+            assert False
+        except Exception as e:
+            self._format_and_raise(key=index, value=None, cause=e)
+            assert False
+
+    def sort(
+        self, key: Optional[Callable[[Any], Any]] = None, reverse: bool = False
+    ) -> None:
+        try:
+            if self._get_flag("readonly"):
+                raise ReadonlyConfigError("Cannot sort a read-only ListConfig")
+            if self._is_none():
+                raise TypeError("Cannot sort a ListConfig object representing None")
+            if self._is_missing():
+                raise MissingMandatoryValue("Cannot sort a missing ListConfig")
+
+            if key is None:
+
+                def key1(x: Any) -> Any:
+                    return x._value()
+
+            else:
+
+                def key1(x: Any) -> Any:
+                    return key(x._value())  # type: ignore
+
+            assert isinstance(self.__dict__["_content"], list)
+            self.__dict__["_content"].sort(key=key1, reverse=reverse)
+
+        except Exception as e:
+            self._format_and_raise(key=None, value=None, cause=e)
+            assert False
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, (list, tuple)) or other is None:
+            other = ListConfig(other, flags={"allow_objects": True})
+            return ListConfig._list_eq(self, other)
+        if other is None or isinstance(other, ListConfig):
+            return ListConfig._list_eq(self, other)
+        if self._is_missing():
+            return _is_missing_literal(other)
+        return NotImplemented
+
+    def __ne__(self, other: Any) -> bool:
+        x = self.__eq__(other)
+        if x is not NotImplemented:
+            return not x
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __iter__(self) -> Iterator[Any]:
+        return self._iter_ex(resolve=True)
+
+    class ListIterator(Iterator[Any]):
+        def __init__(self, lst: Any, resolve: bool) -> None:
+            self.resolve = resolve
+            self.iterator = iter(lst.__dict__["_content"])
+            self.index = 0
+            from .nodes import ValueNode
+
+            self.ValueNode = ValueNode
+
+        def __next__(self) -> Any:
+
+            x = next(self.iterator)
+            if self.resolve:
+                x = x._dereference_node()
+                if x._is_missing():
+                    raise MissingMandatoryValue(f"Missing value at index {self.index}")
+
+            self.index = self.index + 1
+            if isinstance(x, self.ValueNode):
+                return x._value()
+            else:
+                # Must be omegaconf.Container. not checking for perf reasons.
+                if x._is_none():
+                    return None
+                return x
+
+        def __repr__(self) -> str:  # pragma: no cover
+            return f"ListConfig.ListIterator(resolve={self.resolve})"
+
+    def _iter_ex(self, resolve: bool) -> Iterator[Any]:
+        try:
+            if self._is_none():
+                raise TypeError("Cannot iterate a ListConfig object representing None")
+            if self._is_missing():
+                raise MissingMandatoryValue("Cannot iterate a missing ListConfig")
+
+            return ListConfig.ListIterator(self, resolve)
+        except (TypeError, MissingMandatoryValue) as e:
+            self._format_and_raise(key=None, value=None, cause=e)
+            assert False
+
+    def __add__(self, other: Union[List[Any], "ListConfig"]) -> "ListConfig":
+        # res is sharing this list's parent to allow interpolation to work as expected
+        res = ListConfig(parent=self._get_parent(), content=[])
+        res.extend(self)
+        res.extend(other)
+        return res
+
+    def __radd__(self, other: Union[List[Any], "ListConfig"]) -> "ListConfig":
+        # res is sharing this list's parent to allow interpolation to work as expected
+        res = ListConfig(parent=self._get_parent(), content=[])
+        res.extend(other)
+        res.extend(self)
+        return res
+
+    def __iadd__(self, other: Iterable[Any]) -> "ListConfig":
+        self.extend(other)
+        return self
+
+    def __contains__(self, item: Any) -> bool:
+        if self._is_none():
+            raise TypeError(
+                "Cannot check if an item is in a ListConfig object representing None"
+            )
+        if self._is_missing():
+            raise MissingMandatoryValue(
+                "Cannot check if an item is in missing ListConfig"
+            )
+
+        lst = self.__dict__["_content"]
+        for x in lst:
+            x = x._dereference_node()
+            if x == item:
+                return True
+        return False
+
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        try:
+            previous_content = self.__dict__["_content"]
+            previous_metadata = self.__dict__["_metadata"]
+            self._set_value_impl(value, flags)
+        except Exception as e:
+            self.__dict__["_content"] = previous_content
+            self.__dict__["_metadata"] = previous_metadata
+            raise e
+
+    def _set_value_impl(
+        self, value: Any, flags: Optional[Dict[str, bool]] = None
+    ) -> None:
+        from omegaconf import MISSING, flag_override
+
+        if flags is None:
+            flags = {}
+
+        vk = get_value_kind(value, strict_interpolation_validation=True)
+        if _is_none(value):
+            if not self._is_optional():
+                raise ValidationError(
+                    "Non optional ListConfig cannot be constructed from None"
+                )
+            self.__dict__["_content"] = None
+            self._metadata.object_type = None
+        elif vk is ValueKind.MANDATORY_MISSING:
+            self.__dict__["_content"] = MISSING
+            self._metadata.object_type = None
+        elif vk == ValueKind.INTERPOLATION:
+            self.__dict__["_content"] = value
+            self._metadata.object_type = None
+        else:
+            if not (is_primitive_list(value) or isinstance(value, ListConfig)):
+                type_ = type(value)
+                msg = f"Invalid value assigned: {type_.__name__} is not a ListConfig, list or tuple."
+                raise ValidationError(msg)
+
+            self.__dict__["_content"] = []
+            if isinstance(value, ListConfig):
+                self._metadata.flags = copy.deepcopy(flags)
+                # disable struct and readonly for the construction phase
+                # retaining other flags like allow_objects. The real flags are restored at the end of this function
+                with flag_override(self, ["struct", "readonly"], False):
+                    for item in value._iter_ex(resolve=False):
+                        self.append(item)
+            elif is_primitive_list(value):
+                with flag_override(self, ["struct", "readonly"], False):
+                    for item in value:
+                        self.append(item)
+            self._metadata.object_type = list
+
+    @staticmethod
+    def _list_eq(l1: Optional["ListConfig"], l2: Optional["ListConfig"]) -> bool:
+        l1_none = l1.__dict__["_content"] is None
+        l2_none = l2.__dict__["_content"] is None
+        if l1_none and l2_none:
+            return True
+        if l1_none != l2_none:
+            return False
+
+        assert isinstance(l1, ListConfig)
+        assert isinstance(l2, ListConfig)
+        if len(l1) != len(l2):
+            return False
+        for i in range(len(l1)):
+            if not BaseContainer._item_eq(l1, i, l2, i):
+                return False
+
+        return True

lib/python3.12/site-packages/omegaconf/nodes.py

@@ -0,0 +1,545 @@
+import copy
+import math
+import sys
+from abc import abstractmethod
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional, Type, Union
+
+from omegaconf._utils import (
+    ValueKind,
+    _is_interpolation,
+    get_type_of,
+    get_value_kind,
+    is_primitive_container,
+    type_str,
+)
+from omegaconf.base import Box, DictKeyType, Metadata, Node
+from omegaconf.errors import ReadonlyConfigError, UnsupportedValueType, ValidationError
+
+
+class ValueNode(Node):
+    _val: Any
+
+    def __init__(self, parent: Optional[Box], value: Any, metadata: Metadata):
+        from omegaconf import read_write
+
+        super().__init__(parent=parent, metadata=metadata)
+        with read_write(self):
+            self._set_value(value)  # lgtm [py/init-calls-subclass]
+
+    def _value(self) -> Any:
+        return self._val
+
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        if self._get_flag("readonly"):
+            raise ReadonlyConfigError("Cannot set value of read-only config node")
+
+        if isinstance(value, str) and get_value_kind(
+            value, strict_interpolation_validation=True
+        ) in (
+            ValueKind.INTERPOLATION,
+            ValueKind.MANDATORY_MISSING,
+        ):
+            self._val = value
+        else:
+            self._val = self.validate_and_convert(value)
+
+    def _strict_validate_type(self, value: Any) -> None:
+        ref_type = self._metadata.ref_type
+        if isinstance(ref_type, type) and type(value) is not ref_type:
+            type_hint = type_str(self._metadata.type_hint)
+            raise ValidationError(
+                f"Value '$VALUE' of type '$VALUE_TYPE' is incompatible with type hint '{type_hint}'"
+            )
+
+    def validate_and_convert(self, value: Any) -> Any:
+        """
+        Validates input and converts to canonical form
+        :param value: input value
+        :return: converted value ("100" may be converted to 100 for example)
+        """
+        if value is None:
+            if self._is_optional():
+                return None
+            ref_type_str = type_str(self._metadata.ref_type)
+            raise ValidationError(
+                f"Incompatible value '{value}' for field of type '{ref_type_str}'"
+            )
+
+        # Subclasses can assume that `value` is not None in
+        # `_validate_and_convert_impl()` and in `_strict_validate_type()`.
+        if self._get_flag("convert") is False:
+            self._strict_validate_type(value)
+            return value
+        else:
+            return self._validate_and_convert_impl(value)
+
+    @abstractmethod
+    def _validate_and_convert_impl(self, value: Any) -> Any:
+        ...
+
+    def __str__(self) -> str:
+        return str(self._val)
+
+    def __repr__(self) -> str:
+        return repr(self._val) if hasattr(self, "_val") else "__INVALID__"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, AnyNode):
+            return self._val == other._val  # type: ignore
+        else:
+            return self._val == other  # type: ignore
+
+    def __ne__(self, other: Any) -> bool:
+        x = self.__eq__(other)
+        assert x is not NotImplemented
+        return not x
+
+    def __hash__(self) -> int:
+        return hash(self._val)
+
+    def _deepcopy_impl(self, res: Any, memo: Dict[int, Any]) -> None:
+        res.__dict__["_metadata"] = copy.deepcopy(self._metadata, memo=memo)
+        # shallow copy for value to support non-copyable value
+        res.__dict__["_val"] = self._val
+
+        # parent is retained, but not copied
+        res.__dict__["_parent"] = self._parent
+
+    def _is_optional(self) -> bool:
+        return self._metadata.optional
+
+    def _is_interpolation(self) -> bool:
+        return _is_interpolation(self._value())
+
+    def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str:
+        parent = self._get_parent()
+        if parent is None:
+            if self._metadata.key is None:
+                return ""
+            else:
+                return str(self._metadata.key)
+        else:
+            return parent._get_full_key(self._metadata.key)
+
+
+class AnyNode(ValueNode):
+    def __init__(
+        self,
+        value: Any = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                ref_type=Any, object_type=None, key=key, optional=True, flags=flags
+            ),
+        )
+
+    def _validate_and_convert_impl(self, value: Any) -> Any:
+        from ._utils import is_primitive_type_annotation
+
+        # allow_objects is internal and not an official API. use at your own risk.
+        # Please be aware that this support is subject to change without notice.
+        # If this is deemed useful and supportable it may become an official API.
+
+        if self._get_flag(
+            "allow_objects"
+        ) is not True and not is_primitive_type_annotation(value):
+            t = get_type_of(value)
+            raise UnsupportedValueType(
+                f"Value '{t.__name__}' is not a supported primitive type"
+            )
+        return value
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "AnyNode":
+        res = AnyNode()
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class StringNode(ValueNode):
+    def __init__(
+        self,
+        value: Any = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                key=key,
+                optional=is_optional,
+                ref_type=str,
+                object_type=str,
+                flags=flags,
+            ),
+        )
+
+    def _validate_and_convert_impl(self, value: Any) -> str:
+        from omegaconf import OmegaConf
+
+        if (
+            OmegaConf.is_config(value)
+            or is_primitive_container(value)
+            or isinstance(value, bytes)
+        ):
+            raise ValidationError("Cannot convert '$VALUE_TYPE' to string: '$VALUE'")
+        return str(value)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "StringNode":
+        res = StringNode()
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class PathNode(ValueNode):
+    def __init__(
+        self,
+        value: Any = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                key=key,
+                optional=is_optional,
+                ref_type=Path,
+                object_type=Path,
+                flags=flags,
+            ),
+        )
+
+    def _strict_validate_type(self, value: Any) -> None:
+        if not isinstance(value, Path):
+            raise ValidationError(
+                "Value '$VALUE' of type '$VALUE_TYPE' is not an instance of 'pathlib.Path'"
+            )
+
+    def _validate_and_convert_impl(self, value: Any) -> Path:
+        if not isinstance(value, (str, Path)):
+            raise ValidationError(
+                "Value '$VALUE' of type '$VALUE_TYPE' could not be converted to Path"
+            )
+
+        return Path(value)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "PathNode":
+        res = PathNode()
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class IntegerNode(ValueNode):
+    def __init__(
+        self,
+        value: Any = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                key=key,
+                optional=is_optional,
+                ref_type=int,
+                object_type=int,
+                flags=flags,
+            ),
+        )
+
+    def _validate_and_convert_impl(self, value: Any) -> int:
+        try:
+            if type(value) in (str, int):
+                val = int(value)
+            else:
+                raise ValueError()
+        except ValueError:
+            raise ValidationError(
+                "Value '$VALUE' of type '$VALUE_TYPE' could not be converted to Integer"
+            )
+        return val
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "IntegerNode":
+        res = IntegerNode()
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class BytesNode(ValueNode):
+    def __init__(
+        self,
+        value: Any = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                key=key,
+                optional=is_optional,
+                ref_type=bytes,
+                object_type=bytes,
+                flags=flags,
+            ),
+        )
+
+    def _validate_and_convert_impl(self, value: Any) -> bytes:
+        if not isinstance(value, bytes):
+            raise ValidationError(
+                "Value '$VALUE' of type '$VALUE_TYPE' is not of type 'bytes'"
+            )
+        return value
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "BytesNode":
+        res = BytesNode()
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class FloatNode(ValueNode):
+    def __init__(
+        self,
+        value: Any = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                key=key,
+                optional=is_optional,
+                ref_type=float,
+                object_type=float,
+                flags=flags,
+            ),
+        )
+
+    def _validate_and_convert_impl(self, value: Any) -> float:
+        try:
+            if type(value) in (float, str, int):
+                return float(value)
+            else:
+                raise ValueError()
+        except ValueError:
+            raise ValidationError(
+                "Value '$VALUE' of type '$VALUE_TYPE' could not be converted to Float"
+            )
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, ValueNode):
+            other_val = other._val
+        else:
+            other_val = other
+        if self._val is None and other is None:
+            return True
+        if self._val is None and other is not None:
+            return False
+        if self._val is not None and other is None:
+            return False
+        nan1 = math.isnan(self._val) if isinstance(self._val, float) else False
+        nan2 = math.isnan(other_val) if isinstance(other_val, float) else False
+        return self._val == other_val or (nan1 and nan2)
+
+    def __hash__(self) -> int:
+        return hash(self._val)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FloatNode":
+        res = FloatNode()
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class BooleanNode(ValueNode):
+    def __init__(
+        self,
+        value: Any = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                key=key,
+                optional=is_optional,
+                ref_type=bool,
+                object_type=bool,
+                flags=flags,
+            ),
+        )
+
+    def _validate_and_convert_impl(self, value: Any) -> bool:
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, int):
+            return value != 0
+        elif isinstance(value, str):
+            try:
+                return self._validate_and_convert_impl(int(value))
+            except ValueError as e:
+                if value.lower() in ("yes", "y", "on", "true"):
+                    return True
+                elif value.lower() in ("no", "n", "off", "false"):
+                    return False
+                else:
+                    raise ValidationError(
+                        "Value '$VALUE' is not a valid bool (type $VALUE_TYPE)"
+                    ).with_traceback(sys.exc_info()[2]) from e
+        else:
+            raise ValidationError(
+                "Value '$VALUE' is not a valid bool (type $VALUE_TYPE)"
+            )
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "BooleanNode":
+        res = BooleanNode()
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class EnumNode(ValueNode):  # lgtm [py/missing-equals] : Intentional.
+    """
+    NOTE: EnumNode is serialized to yaml as a string ("Color.BLUE"), not as a fully qualified yaml type.
+    this means serialization to YAML of a typed config (with EnumNode) will not retain the type of the Enum
+    when loaded.
+    This is intentional, Please open an issue against OmegaConf if you wish to discuss this decision.
+    """
+
+    def __init__(
+        self,
+        enum_type: Type[Enum],
+        value: Optional[Union[Enum, str]] = None,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        if not isinstance(enum_type, type) or not issubclass(enum_type, Enum):
+            raise ValidationError(
+                f"EnumNode can only operate on Enum subclasses ({enum_type})"
+            )
+        self.fields: Dict[str, str] = {}
+        self.enum_type: Type[Enum] = enum_type
+        for name, constant in enum_type.__members__.items():
+            self.fields[name] = constant.value
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                key=key,
+                optional=is_optional,
+                ref_type=enum_type,
+                object_type=enum_type,
+                flags=flags,
+            ),
+        )
+
+    def _strict_validate_type(self, value: Any) -> None:
+        ref_type = self._metadata.ref_type
+        if not isinstance(value, ref_type):
+            type_hint = type_str(self._metadata.type_hint)
+            raise ValidationError(
+                f"Value '$VALUE' of type '$VALUE_TYPE' is incompatible with type hint '{type_hint}'"
+            )
+
+    def _validate_and_convert_impl(self, value: Any) -> Enum:
+        return self.validate_and_convert_to_enum(enum_type=self.enum_type, value=value)
+
+    @staticmethod
+    def validate_and_convert_to_enum(enum_type: Type[Enum], value: Any) -> Enum:
+        if not isinstance(value, (str, int)) and not isinstance(value, enum_type):
+            raise ValidationError(
+                f"Value $VALUE ($VALUE_TYPE) is not a valid input for {enum_type}"
+            )
+
+        if isinstance(value, enum_type):
+            return value
+
+        try:
+            if isinstance(value, (float, bool)):
+                raise ValueError
+
+            if isinstance(value, int):
+                return enum_type(value)
+
+            if isinstance(value, str):
+                prefix = f"{enum_type.__name__}."
+                if value.startswith(prefix):
+                    value = value[len(prefix) :]
+                return enum_type[value]
+
+            assert False
+
+        except (ValueError, KeyError) as e:
+            valid = ", ".join([x for x in enum_type.__members__.keys()])
+            raise ValidationError(
+                f"Invalid value '$VALUE', expected one of [{valid}]"
+            ).with_traceback(sys.exc_info()[2]) from e
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "EnumNode":
+        res = EnumNode(enum_type=self.enum_type)
+        self._deepcopy_impl(res, memo)
+        return res
+
+
+class InterpolationResultNode(ValueNode):
+    """
+    Special node type, used to wrap interpolation results.
+    """
+
+    def __init__(
+        self,
+        value: Any,
+        key: Any = None,
+        parent: Optional[Box] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ):
+        super().__init__(
+            parent=parent,
+            value=value,
+            metadata=Metadata(
+                ref_type=Any, object_type=None, key=key, optional=True, flags=flags
+            ),
+        )
+        # In general we should not try to write into interpolation results.
+        if flags is None or "readonly" not in flags:
+            self._set_flag("readonly", True)
+
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        if self._get_flag("readonly"):
+            raise ReadonlyConfigError("Cannot set value of read-only config node")
+        self._val = self.validate_and_convert(value)
+
+    def _validate_and_convert_impl(self, value: Any) -> Any:
+        # Interpolation results may be anything.
+        return value
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "InterpolationResultNode":
+        # Currently there should be no need to deep-copy such nodes.
+        raise NotImplementedError
+
+    def _is_interpolation(self) -> bool:
+        # The result of an interpolation cannot be itself an interpolation.
+        return False

lib/python3.12/site-packages/omegaconf/omegaconf.py

@@ -0,0 +1,1157 @@
+"""OmegaConf module"""
+import copy
+import inspect
+import io
+import os
+import pathlib
+import sys
+import warnings
+from collections import defaultdict
+from contextlib import contextmanager
+from enum import Enum
+from textwrap import dedent
+from typing import (
+    IO,
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    overload,
+)
+
+import yaml
+
+from . import DictConfig, DictKeyType, ListConfig
+from ._utils import (
+    _DEFAULT_MARKER_,
+    _ensure_container,
+    _get_value,
+    format_and_raise,
+    get_dict_key_value_types,
+    get_list_element_type,
+    get_omega_conf_dumper,
+    get_type_of,
+    is_attr_class,
+    is_dataclass,
+    is_dict_annotation,
+    is_int,
+    is_list_annotation,
+    is_primitive_container,
+    is_primitive_dict,
+    is_primitive_list,
+    is_structured_config,
+    is_tuple_annotation,
+    is_union_annotation,
+    nullcontext,
+    split_key,
+    type_str,
+)
+from .base import Box, Container, Node, SCMode, UnionNode
+from .basecontainer import BaseContainer
+from .errors import (
+    MissingMandatoryValue,
+    OmegaConfBaseException,
+    UnsupportedInterpolationType,
+    ValidationError,
+)
+from .nodes import (
+    AnyNode,
+    BooleanNode,
+    BytesNode,
+    EnumNode,
+    FloatNode,
+    IntegerNode,
+    PathNode,
+    StringNode,
+    ValueNode,
+)
+
+MISSING: Any = "???"
+
+Resolver = Callable[..., Any]
+
+
+def II(interpolation: str) -> Any:
+    """
+    Equivalent to ``${interpolation}``
+
+    :param interpolation:
+    :return: input ``${node}`` with type Any
+    """
+    return "${" + interpolation + "}"
+
+
+def SI(interpolation: str) -> Any:
+    """
+    Use this for String interpolation, for example ``"http://${host}:${port}"``
+
+    :param interpolation: interpolation string
+    :return: input interpolation with type ``Any``
+    """
+    return interpolation
+
+
+def register_default_resolvers() -> None:
+    from omegaconf.resolvers import oc
+
+    OmegaConf.register_new_resolver("oc.create", oc.create)
+    OmegaConf.register_new_resolver("oc.decode", oc.decode)
+    OmegaConf.register_new_resolver("oc.deprecated", oc.deprecated)
+    OmegaConf.register_new_resolver("oc.env", oc.env)
+    OmegaConf.register_new_resolver("oc.select", oc.select)
+    OmegaConf.register_new_resolver("oc.dict.keys", oc.dict.keys)
+    OmegaConf.register_new_resolver("oc.dict.values", oc.dict.values)
+
+
+class OmegaConf:
+    """OmegaConf primary class"""
+
+    def __init__(self) -> None:
+        raise NotImplementedError("Use one of the static construction functions")
+
+    @staticmethod
+    def structured(
+        obj: Any,
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> Any:
+        return OmegaConf.create(obj, parent, flags)
+
+    @staticmethod
+    @overload
+    def create(
+        obj: str,
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> Union[DictConfig, ListConfig]:
+        ...
+
+    @staticmethod
+    @overload
+    def create(
+        obj: Union[List[Any], Tuple[Any, ...]],
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> ListConfig:
+        ...
+
+    @staticmethod
+    @overload
+    def create(
+        obj: DictConfig,
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> DictConfig:
+        ...
+
+    @staticmethod
+    @overload
+    def create(
+        obj: ListConfig,
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> ListConfig:
+        ...
+
+    @staticmethod
+    @overload
+    def create(
+        obj: Optional[Dict[Any, Any]] = None,
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> DictConfig:
+        ...
+
+    @staticmethod
+    def create(  # noqa F811
+        obj: Any = _DEFAULT_MARKER_,
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> Union[DictConfig, ListConfig]:
+        return OmegaConf._create_impl(
+            obj=obj,
+            parent=parent,
+            flags=flags,
+        )
+
+    @staticmethod
+    def load(file_: Union[str, pathlib.Path, IO[Any]]) -> Union[DictConfig, ListConfig]:
+        from ._utils import get_yaml_loader
+
+        if isinstance(file_, (str, pathlib.Path)):
+            with io.open(os.path.abspath(file_), "r", encoding="utf-8") as f:
+                obj = yaml.load(f, Loader=get_yaml_loader())
+        elif getattr(file_, "read", None):
+            obj = yaml.load(file_, Loader=get_yaml_loader())
+        else:
+            raise TypeError("Unexpected file type")
+
+        if obj is not None and not isinstance(obj, (list, dict, str)):
+            raise IOError(  # pragma: no cover
+                f"Invalid loaded object type: {type(obj).__name__}"
+            )
+
+        ret: Union[DictConfig, ListConfig]
+        if obj is None:
+            ret = OmegaConf.create()
+        else:
+            ret = OmegaConf.create(obj)
+        return ret
+
+    @staticmethod
+    def save(
+        config: Any, f: Union[str, pathlib.Path, IO[Any]], resolve: bool = False
+    ) -> None:
+        """
+        Save as configuration object to a file
+
+        :param config: omegaconf.Config object (DictConfig or ListConfig).
+        :param f: filename or file object
+        :param resolve: True to save a resolved config (defaults to False)
+        """
+        if is_dataclass(config) or is_attr_class(config):
+            config = OmegaConf.create(config)
+        data = OmegaConf.to_yaml(config, resolve=resolve)
+        if isinstance(f, (str, pathlib.Path)):
+            with io.open(os.path.abspath(f), "w", encoding="utf-8") as file:
+                file.write(data)
+        elif hasattr(f, "write"):
+            f.write(data)
+            f.flush()
+        else:
+            raise TypeError("Unexpected file type")
+
+    @staticmethod
+    def from_cli(args_list: Optional[List[str]] = None) -> DictConfig:
+        if args_list is None:
+            # Skip program name
+            args_list = sys.argv[1:]
+        return OmegaConf.from_dotlist(args_list)
+
+    @staticmethod
+    def from_dotlist(dotlist: List[str]) -> DictConfig:
+        """
+        Creates config from the content sys.argv or from the specified args list of not None
+
+        :param dotlist: A list of dotlist-style strings, e.g. ``["foo.bar=1", "baz=qux"]``.
+        :return: A ``DictConfig`` object created from the dotlist.
+        """
+        conf = OmegaConf.create()
+        conf.merge_with_dotlist(dotlist)
+        return conf
+
+    @staticmethod
+    def merge(
+        *configs: Union[
+            DictConfig,
+            ListConfig,
+            Dict[DictKeyType, Any],
+            List[Any],
+            Tuple[Any, ...],
+            Any,
+        ],
+    ) -> Union[ListConfig, DictConfig]:
+        """
+        Merge a list of previously created configs into a single one
+
+        :param configs: Input configs
+        :return: the merged config object.
+        """
+        assert len(configs) > 0
+        target = copy.deepcopy(configs[0])
+        target = _ensure_container(target)
+        assert isinstance(target, (DictConfig, ListConfig))
+
+        with flag_override(target, "readonly", False):
+            target.merge_with(*configs[1:])
+            turned_readonly = target._get_flag("readonly") is True
+
+        if turned_readonly:
+            OmegaConf.set_readonly(target, True)
+
+        return target
+
+    @staticmethod
+    def unsafe_merge(
+        *configs: Union[
+            DictConfig,
+            ListConfig,
+            Dict[DictKeyType, Any],
+            List[Any],
+            Tuple[Any, ...],
+            Any,
+        ],
+    ) -> Union[ListConfig, DictConfig]:
+        """
+        Merge a list of previously created configs into a single one
+        This is much faster than OmegaConf.merge() as the input configs are not copied.
+        However, the input configs must not be used after this operation as will become inconsistent.
+
+        :param configs: Input configs
+        :return: the merged config object.
+        """
+        assert len(configs) > 0
+        target = configs[0]
+        target = _ensure_container(target)
+        assert isinstance(target, (DictConfig, ListConfig))
+
+        with flag_override(
+            target, ["readonly", "no_deepcopy_set_nodes"], [False, True]
+        ):
+            target.merge_with(*configs[1:])
+            turned_readonly = target._get_flag("readonly") is True
+
+        if turned_readonly:
+            OmegaConf.set_readonly(target, True)
+
+        return target
+
+    @staticmethod
+    def register_resolver(name: str, resolver: Resolver) -> None:
+        warnings.warn(
+            dedent(
+                """\
+            register_resolver() is deprecated.
+            See https://github.com/omry/omegaconf/issues/426 for migration instructions.
+            """
+            ),
+            stacklevel=2,
+        )
+        return OmegaConf.legacy_register_resolver(name, resolver)
+
+    # This function will eventually be deprecated and removed.
+    @staticmethod
+    def legacy_register_resolver(name: str, resolver: Resolver) -> None:
+        assert callable(resolver), "resolver must be callable"
+        # noinspection PyProtectedMember
+        assert (
+            name not in BaseContainer._resolvers
+        ), f"resolver '{name}' is already registered"
+
+        def resolver_wrapper(
+            config: BaseContainer,
+            parent: BaseContainer,
+            node: Node,
+            args: Tuple[Any, ...],
+            args_str: Tuple[str, ...],
+        ) -> Any:
+            cache = OmegaConf.get_cache(config)[name]
+            # "Un-escape " spaces and commas.
+            args_unesc = [x.replace(r"\ ", " ").replace(r"\,", ",") for x in args_str]
+
+            # Nested interpolations behave in a potentially surprising way with
+            # legacy resolvers (they remain as strings, e.g., "${foo}"). If any
+            # input looks like an interpolation we thus raise an exception.
+            try:
+                bad_arg = next(i for i in args_unesc if "${" in i)
+            except StopIteration:
+                pass
+            else:
+                raise ValueError(
+                    f"Resolver '{name}' was called with argument '{bad_arg}' that appears "
+                    f"to be an interpolation. Nested interpolations are not supported for "
+                    f"resolvers registered with `[legacy_]register_resolver()`, please use "
+                    f"`register_new_resolver()` instead (see "
+                    f"https://github.com/omry/omegaconf/issues/426 for migration instructions)."
+                )
+            key = args_str
+            val = cache[key] if key in cache else resolver(*args_unesc)
+            cache[key] = val
+            return val
+
+        # noinspection PyProtectedMember
+        BaseContainer._resolvers[name] = resolver_wrapper
+
+    @staticmethod
+    def register_new_resolver(
+        name: str,
+        resolver: Resolver,
+        *,
+        replace: bool = False,
+        use_cache: bool = False,
+    ) -> None:
+        """
+        Register a resolver.
+
+        :param name: Name of the resolver.
+        :param resolver: Callable whose arguments are provided in the interpolation,
+            e.g., with ${foo:x,0,${y.z}} these arguments are respectively "x" (str),
+            0 (int) and the value of ``y.z``.
+        :param replace: If set to ``False`` (default), then a ``ValueError`` is raised if
+            an existing resolver has already been registered with the same name.
+            If set to ``True``, then the new resolver replaces the previous one.
+            NOTE: The cache on existing config objects is not affected, use
+            ``OmegaConf.clear_cache(cfg)`` to clear it.
+        :param use_cache: Whether the resolver's outputs should be cached. The cache is
+            based only on the string literals representing the resolver arguments, e.g.,
+            ${foo:${bar}} will always return the same value regardless of the value of
+            ``bar`` if the cache is enabled for ``foo``.
+        """
+        if not callable(resolver):
+            raise TypeError("resolver must be callable")
+        if not name:
+            raise ValueError("cannot use an empty resolver name")
+
+        if not replace and OmegaConf.has_resolver(name):
+            raise ValueError(f"resolver '{name}' is already registered")
+
+        try:
+            sig: Optional[inspect.Signature] = inspect.signature(resolver)
+        except ValueError:
+            sig = None
+
+        def _should_pass(special: str) -> bool:
+            ret = sig is not None and special in sig.parameters
+            if ret and use_cache:
+                raise ValueError(
+                    f"use_cache=True is incompatible with functions that receive the {special}"
+                )
+            return ret
+
+        pass_parent = _should_pass("_parent_")
+        pass_node = _should_pass("_node_")
+        pass_root = _should_pass("_root_")
+
+        def resolver_wrapper(
+            config: BaseContainer,
+            parent: Container,
+            node: Node,
+            args: Tuple[Any, ...],
+            args_str: Tuple[str, ...],
+        ) -> Any:
+            if use_cache:
+                cache = OmegaConf.get_cache(config)[name]
+                try:
+                    return cache[args_str]
+                except KeyError:
+                    pass
+
+            # Call resolver.
+            kwargs: Dict[str, Node] = {}
+            if pass_parent:
+                kwargs["_parent_"] = parent
+            if pass_node:
+                kwargs["_node_"] = node
+            if pass_root:
+                kwargs["_root_"] = config
+
+            ret = resolver(*args, **kwargs)
+
+            if use_cache:
+                cache[args_str] = ret
+            return ret
+
+        # noinspection PyProtectedMember
+        BaseContainer._resolvers[name] = resolver_wrapper
+
+    @classmethod
+    def has_resolver(cls, name: str) -> bool:
+        return cls._get_resolver(name) is not None
+
+    # noinspection PyProtectedMember
+    @staticmethod
+    def clear_resolvers() -> None:
+        """
+        Clear(remove) all OmegaConf resolvers, then re-register OmegaConf's default resolvers.
+        """
+        BaseContainer._resolvers = {}
+        register_default_resolvers()
+
+    @classmethod
+    def clear_resolver(cls, name: str) -> bool:
+        """
+        Clear(remove) any resolver only if it exists.
+
+        Returns a bool: True if resolver is removed and False if not removed.
+
+        .. warning:
+            This method can remove deafult resolvers as well.
+
+        :param name: Name of the resolver.
+        :return: A bool (``True`` if resolver is removed, ``False`` if not found before removing).
+        """
+        if cls.has_resolver(name):
+            BaseContainer._resolvers.pop(name)
+            return True
+        else:
+            # return False if resolver does not exist
+            return False
+
+    @staticmethod
+    def get_cache(conf: BaseContainer) -> Dict[str, Any]:
+        return conf._metadata.resolver_cache
+
+    @staticmethod
+    def set_cache(conf: BaseContainer, cache: Dict[str, Any]) -> None:
+        conf._metadata.resolver_cache = copy.deepcopy(cache)
+
+    @staticmethod
+    def clear_cache(conf: BaseContainer) -> None:
+        OmegaConf.set_cache(conf, defaultdict(dict, {}))
+
+    @staticmethod
+    def copy_cache(from_config: BaseContainer, to_config: BaseContainer) -> None:
+        OmegaConf.set_cache(to_config, OmegaConf.get_cache(from_config))
+
+    @staticmethod
+    def set_readonly(conf: Node, value: Optional[bool]) -> None:
+        # noinspection PyProtectedMember
+        conf._set_flag("readonly", value)
+
+    @staticmethod
+    def is_readonly(conf: Node) -> Optional[bool]:
+        # noinspection PyProtectedMember
+        return conf._get_flag("readonly")
+
+    @staticmethod
+    def set_struct(conf: Container, value: Optional[bool]) -> None:
+        # noinspection PyProtectedMember
+        conf._set_flag("struct", value)
+
+    @staticmethod
+    def is_struct(conf: Container) -> Optional[bool]:
+        # noinspection PyProtectedMember
+        return conf._get_flag("struct")
+
+    @staticmethod
+    def masked_copy(conf: DictConfig, keys: Union[str, List[str]]) -> DictConfig:
+        """
+        Create a masked copy of of this config that contains a subset of the keys
+
+        :param conf: DictConfig object
+        :param keys: keys to preserve in the copy
+        :return: The masked ``DictConfig`` object.
+        """
+        from .dictconfig import DictConfig
+
+        if not isinstance(conf, DictConfig):
+            raise ValueError("masked_copy is only supported for DictConfig")
+
+        if isinstance(keys, str):
+            keys = [keys]
+        content = {key: value for key, value in conf.items_ex(resolve=False, keys=keys)}
+        return DictConfig(content=content)
+
+    @staticmethod
+    def to_container(
+        cfg: Any,
+        *,
+        resolve: bool = False,
+        throw_on_missing: bool = False,
+        enum_to_str: bool = False,
+        structured_config_mode: SCMode = SCMode.DICT,
+    ) -> Union[Dict[DictKeyType, Any], List[Any], None, str, Any]:
+        """
+        Resursively converts an OmegaConf config to a primitive container (dict or list).
+
+        :param cfg: the config to convert
+        :param resolve: True to resolve all values
+        :param throw_on_missing: When True, raise MissingMandatoryValue if any missing values are present.
+            When False (the default), replace missing values with the string "???" in the output container.
+        :param enum_to_str: True to convert Enum keys and values to strings
+        :param structured_config_mode: Specify how Structured Configs (DictConfigs backed by a dataclass) are handled.
+            - By default (``structured_config_mode=SCMode.DICT``) structured configs are converted to plain dicts.
+            - If ``structured_config_mode=SCMode.DICT_CONFIG``, structured config nodes will remain as DictConfig.
+            - If ``structured_config_mode=SCMode.INSTANTIATE``, this function will instantiate structured configs
+              (DictConfigs backed by a dataclass), by creating an instance of the underlying dataclass.
+
+          See also OmegaConf.to_object.
+        :return: A dict or a list representing this config as a primitive container.
+        """
+        if not OmegaConf.is_config(cfg):
+            raise ValueError(
+                f"Input cfg is not an OmegaConf config object ({type_str(type(cfg))})"
+            )
+
+        return BaseContainer._to_content(
+            cfg,
+            resolve=resolve,
+            throw_on_missing=throw_on_missing,
+            enum_to_str=enum_to_str,
+            structured_config_mode=structured_config_mode,
+        )
+
+    @staticmethod
+    def to_object(cfg: Any) -> Union[Dict[DictKeyType, Any], List[Any], None, str, Any]:
+        """
+        Resursively converts an OmegaConf config to a primitive container (dict or list).
+        Any DictConfig objects backed by dataclasses or attrs classes are instantiated
+        as instances of those backing classes.
+
+        This is an alias for OmegaConf.to_container(..., resolve=True, throw_on_missing=True,
+                                                    structured_config_mode=SCMode.INSTANTIATE)
+
+        :param cfg: the config to convert
+        :return: A dict or a list or dataclass representing this config.
+        """
+        return OmegaConf.to_container(
+            cfg=cfg,
+            resolve=True,
+            throw_on_missing=True,
+            enum_to_str=False,
+            structured_config_mode=SCMode.INSTANTIATE,
+        )
+
+    @staticmethod
+    def is_missing(cfg: Any, key: DictKeyType) -> bool:
+        assert isinstance(cfg, Container)
+        try:
+            node = cfg._get_child(key)
+            if node is None:
+                return False
+            assert isinstance(node, Node)
+            return node._is_missing()
+        except (UnsupportedInterpolationType, KeyError, AttributeError):
+            return False
+
+    @staticmethod
+    def is_interpolation(node: Any, key: Optional[Union[int, str]] = None) -> bool:
+        if key is not None:
+            assert isinstance(node, Container)
+            target = node._get_child(key)
+        else:
+            target = node
+        if target is not None:
+            assert isinstance(target, Node)
+            return target._is_interpolation()
+        return False
+
+    @staticmethod
+    def is_list(obj: Any) -> bool:
+        from . import ListConfig
+
+        return isinstance(obj, ListConfig)
+
+    @staticmethod
+    def is_dict(obj: Any) -> bool:
+        from . import DictConfig
+
+        return isinstance(obj, DictConfig)
+
+    @staticmethod
+    def is_config(obj: Any) -> bool:
+        from . import Container
+
+        return isinstance(obj, Container)
+
+    @staticmethod
+    def get_type(obj: Any, key: Optional[str] = None) -> Optional[Type[Any]]:
+        if key is not None:
+            c = obj._get_child(key)
+        else:
+            c = obj
+        return OmegaConf._get_obj_type(c)
+
+    @staticmethod
+    def select(
+        cfg: Container,
+        key: str,
+        *,
+        default: Any = _DEFAULT_MARKER_,
+        throw_on_resolution_failure: bool = True,
+        throw_on_missing: bool = False,
+    ) -> Any:
+        """
+        :param cfg: Config node to select from
+        :param key: Key to select
+        :param default: Default value to return if key is not found
+        :param throw_on_resolution_failure: Raise an exception if an interpolation
+               resolution error occurs, otherwise return None
+        :param throw_on_missing: Raise an exception if an attempt to select a missing key (with the value '???')
+               is made, otherwise return None
+        :return: selected value or None if not found.
+        """
+        from ._impl import select_value
+
+        try:
+            return select_value(
+                cfg=cfg,
+                key=key,
+                default=default,
+                throw_on_resolution_failure=throw_on_resolution_failure,
+                throw_on_missing=throw_on_missing,
+            )
+        except Exception as e:
+            format_and_raise(node=cfg, key=key, value=None, cause=e, msg=str(e))
+
+    @staticmethod
+    def update(
+        cfg: Container,
+        key: str,
+        value: Any = None,
+        *,
+        merge: bool = True,
+        force_add: bool = False,
+    ) -> None:
+        """
+        Updates a dot separated key sequence to a value
+
+        :param cfg: input config to update
+        :param key: key to update (can be a dot separated path)
+        :param value: value to set, if value if a list or a dict it will be merged or set
+            depending on merge_config_values
+        :param merge: If value is a dict or a list, True (default) to merge
+                      into the destination, False to replace the destination.
+        :param force_add: insert the entire path regardless of Struct flag or Structured Config nodes.
+        """
+
+        split = split_key(key)
+        root = cfg
+        for i in range(len(split) - 1):
+            k = split[i]
+            # if next_root is a primitive (string, int etc) replace it with an empty map
+            next_root, key_ = _select_one(root, k, throw_on_missing=False)
+            if not isinstance(next_root, Container):
+                if force_add:
+                    with flag_override(root, "struct", False):
+                        root[key_] = {}
+                else:
+                    root[key_] = {}
+            root = root[key_]
+
+        last = split[-1]
+
+        assert isinstance(
+            root, Container
+        ), f"Unexpected type for root: {type(root).__name__}"
+
+        last_key: Union[str, int] = last
+        if isinstance(root, ListConfig):
+            last_key = int(last)
+
+        ctx = flag_override(root, "struct", False) if force_add else nullcontext()
+        with ctx:
+            if merge and (OmegaConf.is_config(value) or is_primitive_container(value)):
+                assert isinstance(root, BaseContainer)
+                node = root._get_child(last_key)
+                if OmegaConf.is_config(node):
+                    assert isinstance(node, BaseContainer)
+                    node.merge_with(value)
+                    return
+
+            if OmegaConf.is_dict(root):
+                assert isinstance(last_key, str)
+                root.__setattr__(last_key, value)
+            elif OmegaConf.is_list(root):
+                assert isinstance(last_key, int)
+                root.__setitem__(last_key, value)
+            else:
+                assert False
+
+    @staticmethod
+    def to_yaml(cfg: Any, *, resolve: bool = False, sort_keys: bool = False) -> str:
+        """
+        returns a yaml dump of this config object.
+
+        :param cfg: Config object, Structured Config type or instance
+        :param resolve: if True, will return a string with the interpolations resolved, otherwise
+            interpolations are preserved
+        :param sort_keys: If True, will print dict keys in sorted order. default False.
+        :return: A string containing the yaml representation.
+        """
+        cfg = _ensure_container(cfg)
+        container = OmegaConf.to_container(cfg, resolve=resolve, enum_to_str=True)
+        return yaml.dump(  # type: ignore
+            container,
+            default_flow_style=False,
+            allow_unicode=True,
+            sort_keys=sort_keys,
+            Dumper=get_omega_conf_dumper(),
+        )
+
+    @staticmethod
+    def resolve(cfg: Container) -> None:
+        """
+        Resolves all interpolations in the given config object in-place.
+
+        :param cfg: An OmegaConf container (DictConfig, ListConfig)
+                    Raises a ValueError if the input object is not an OmegaConf container.
+        """
+        import omegaconf._impl
+
+        if not OmegaConf.is_config(cfg):
+            # Since this function is mutating the input object in-place, it doesn't make sense to
+            # auto-convert the input object to an OmegaConf container
+            raise ValueError(
+                f"Invalid config type ({type(cfg).__name__}), expected an OmegaConf Container"
+            )
+        omegaconf._impl._resolve(cfg)
+
+    @staticmethod
+    def missing_keys(cfg: Any) -> Set[str]:
+        """
+        Returns a set of missing keys in a dotlist style.
+
+        :param cfg: An ``OmegaConf.Container``,
+                    or a convertible object via ``OmegaConf.create`` (dict, list, ...).
+        :return: set of strings of the missing keys.
+        :raises ValueError: On input not representing a config.
+        """
+        cfg = _ensure_container(cfg)
+        missings: Set[str] = set()
+
+        def gather(_cfg: Container) -> None:
+            itr: Iterable[Any]
+            if isinstance(_cfg, ListConfig):
+                itr = range(len(_cfg))
+            else:
+                itr = _cfg
+
+            for key in itr:
+                if OmegaConf.is_missing(_cfg, key):
+                    missings.add(_cfg._get_full_key(key))
+                elif OmegaConf.is_config(_cfg[key]):
+                    gather(_cfg[key])
+
+        gather(cfg)
+        return missings
+
+    # === private === #
+
+    @staticmethod
+    def _create_impl(  # noqa F811
+        obj: Any = _DEFAULT_MARKER_,
+        parent: Optional[BaseContainer] = None,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> Union[DictConfig, ListConfig]:
+        try:
+            from ._utils import get_yaml_loader
+            from .dictconfig import DictConfig
+            from .listconfig import ListConfig
+
+            if obj is _DEFAULT_MARKER_:
+                obj = {}
+            if isinstance(obj, str):
+                obj = yaml.load(obj, Loader=get_yaml_loader())
+                if obj is None:
+                    return OmegaConf.create({}, parent=parent, flags=flags)
+                elif isinstance(obj, str):
+                    return OmegaConf.create({obj: None}, parent=parent, flags=flags)
+                else:
+                    assert isinstance(obj, (list, dict))
+                    return OmegaConf.create(obj, parent=parent, flags=flags)
+
+            else:
+                if (
+                    is_primitive_dict(obj)
+                    or OmegaConf.is_dict(obj)
+                    or is_structured_config(obj)
+                    or obj is None
+                ):
+                    if isinstance(obj, DictConfig):
+                        return DictConfig(
+                            content=obj,
+                            parent=parent,
+                            ref_type=obj._metadata.ref_type,
+                            is_optional=obj._metadata.optional,
+                            key_type=obj._metadata.key_type,
+                            element_type=obj._metadata.element_type,
+                            flags=flags,
+                        )
+                    else:
+                        obj_type = OmegaConf.get_type(obj)
+                        key_type, element_type = get_dict_key_value_types(obj_type)
+                        return DictConfig(
+                            content=obj,
+                            parent=parent,
+                            key_type=key_type,
+                            element_type=element_type,
+                            flags=flags,
+                        )
+                elif is_primitive_list(obj) or OmegaConf.is_list(obj):
+                    if isinstance(obj, ListConfig):
+                        return ListConfig(
+                            content=obj,
+                            parent=parent,
+                            element_type=obj._metadata.element_type,
+                            ref_type=obj._metadata.ref_type,
+                            is_optional=obj._metadata.optional,
+                            flags=flags,
+                        )
+                    else:
+                        obj_type = OmegaConf.get_type(obj)
+                        element_type = get_list_element_type(obj_type)
+                        return ListConfig(
+                            content=obj,
+                            parent=parent,
+                            element_type=element_type,
+                            ref_type=Any,
+                            is_optional=True,
+                            flags=flags,
+                        )
+                else:
+                    if isinstance(obj, type):
+                        raise ValidationError(
+                            f"Input class '{obj.__name__}' is not a structured config. "
+                            "did you forget to decorate it as a dataclass?"
+                        )
+                    else:
+                        raise ValidationError(
+                            f"Object of unsupported type: '{type(obj).__name__}'"
+                        )
+        except OmegaConfBaseException as e:
+            format_and_raise(node=None, key=None, value=None, msg=str(e), cause=e)
+            assert False
+
+    @staticmethod
+    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, UnionNode):
+            return type(_get_value(c))
+        elif isinstance(c, dict):
+            return dict
+        elif isinstance(c, (list, tuple)):
+            return list
+        else:
+            return get_type_of(c)
+
+    @staticmethod
+    def _get_resolver(
+        name: str,
+    ) -> Optional[
+        Callable[
+            [Container, Container, Node, Tuple[Any, ...], Tuple[str, ...]],
+            Any,
+        ]
+    ]:
+        # noinspection PyProtectedMember
+        return (
+            BaseContainer._resolvers[name] if name in BaseContainer._resolvers else None
+        )
+
+
+# register all default resolvers
+register_default_resolvers()
+
+
+@contextmanager
+def flag_override(
+    config: Node,
+    names: Union[List[str], str],
+    values: Union[List[Optional[bool]], Optional[bool]],
+) -> Generator[Node, None, None]:
+    if isinstance(names, str):
+        names = [names]
+    if values is None or isinstance(values, bool):
+        values = [values]
+
+    prev_states = [config._get_node_flag(name) for name in names]
+
+    try:
+        config._set_flag(names, values)
+        yield config
+    finally:
+        config._set_flag(names, prev_states)
+
+
+@contextmanager
+def read_write(config: Node) -> Generator[Node, None, None]:
+    prev_state = config._get_node_flag("readonly")
+    try:
+        OmegaConf.set_readonly(config, False)
+        yield config
+    finally:
+        OmegaConf.set_readonly(config, prev_state)
+
+
+@contextmanager
+def open_dict(config: Container) -> Generator[Container, None, None]:
+    prev_state = config._get_node_flag("struct")
+    try:
+        OmegaConf.set_struct(config, False)
+        yield config
+    finally:
+        OmegaConf.set_struct(config, prev_state)
+
+
+# === private === #
+
+
+def _node_wrap(
+    parent: Optional[Box],
+    is_optional: bool,
+    value: Any,
+    key: Any,
+    ref_type: Any = Any,
+) -> Node:
+    node: Node
+    if is_dict_annotation(ref_type) or (is_primitive_dict(value) and ref_type is Any):
+        key_type, element_type = get_dict_key_value_types(ref_type)
+        node = DictConfig(
+            content=value,
+            key=key,
+            parent=parent,
+            ref_type=ref_type,
+            is_optional=is_optional,
+            key_type=key_type,
+            element_type=element_type,
+        )
+    elif (is_list_annotation(ref_type) or is_tuple_annotation(ref_type)) or (
+        type(value) in (list, tuple) and ref_type is Any
+    ):
+        element_type = get_list_element_type(ref_type)
+        node = ListConfig(
+            content=value,
+            key=key,
+            parent=parent,
+            is_optional=is_optional,
+            element_type=element_type,
+            ref_type=ref_type,
+        )
+    elif is_structured_config(ref_type) or is_structured_config(value):
+        key_type, element_type = get_dict_key_value_types(value)
+        node = DictConfig(
+            ref_type=ref_type,
+            is_optional=is_optional,
+            content=value,
+            key=key,
+            parent=parent,
+            key_type=key_type,
+            element_type=element_type,
+        )
+    elif is_union_annotation(ref_type):
+        node = UnionNode(
+            content=value,
+            ref_type=ref_type,
+            is_optional=is_optional,
+            key=key,
+            parent=parent,
+        )
+    elif ref_type == Any or ref_type is None:
+        node = AnyNode(value=value, key=key, parent=parent)
+    elif isinstance(ref_type, type) and issubclass(ref_type, Enum):
+        node = EnumNode(
+            enum_type=ref_type,
+            value=value,
+            key=key,
+            parent=parent,
+            is_optional=is_optional,
+        )
+    elif ref_type == int:
+        node = IntegerNode(value=value, key=key, parent=parent, is_optional=is_optional)
+    elif ref_type == float:
+        node = FloatNode(value=value, key=key, parent=parent, is_optional=is_optional)
+    elif ref_type == bool:
+        node = BooleanNode(value=value, key=key, parent=parent, is_optional=is_optional)
+    elif ref_type == str:
+        node = StringNode(value=value, key=key, parent=parent, is_optional=is_optional)
+    elif ref_type == bytes:
+        node = BytesNode(value=value, key=key, parent=parent, is_optional=is_optional)
+    elif ref_type == pathlib.Path:
+        node = PathNode(value=value, key=key, parent=parent, is_optional=is_optional)
+    else:
+        if parent is not None and parent._get_flag("allow_objects") is True:
+            if type(value) in (list, tuple):
+                node = ListConfig(
+                    content=value,
+                    key=key,
+                    parent=parent,
+                    ref_type=ref_type,
+                    is_optional=is_optional,
+                )
+            elif is_primitive_dict(value):
+                node = DictConfig(
+                    content=value,
+                    key=key,
+                    parent=parent,
+                    ref_type=ref_type,
+                    is_optional=is_optional,
+                )
+            else:
+                node = AnyNode(value=value, key=key, parent=parent)
+        else:
+            raise ValidationError(f"Unexpected type annotation: {type_str(ref_type)}")
+    return node
+
+
+def _maybe_wrap(
+    ref_type: Any,
+    key: Any,
+    value: Any,
+    is_optional: bool,
+    parent: Optional[BaseContainer],
+) -> Node:
+    # if already a node, update key and parent and return as is.
+    # NOTE: that this mutate the input node!
+    if isinstance(value, Node):
+        value._set_key(key)
+        value._set_parent(parent)
+        return value
+    else:
+        return _node_wrap(
+            ref_type=ref_type,
+            parent=parent,
+            is_optional=is_optional,
+            value=value,
+            key=key,
+        )
+
+
+def _select_one(
+    c: Container, key: str, throw_on_missing: bool, throw_on_type_error: bool = True
+) -> Tuple[Optional[Node], Union[str, int]]:
+    from .dictconfig import DictConfig
+    from .listconfig import ListConfig
+
+    ret_key: Union[str, int] = key
+    assert isinstance(c, Container), f"Unexpected type: {c}"
+    if c._is_none():
+        return None, ret_key
+
+    if isinstance(c, DictConfig):
+        assert isinstance(ret_key, str)
+        val = c._get_child(ret_key, validate_access=False)
+    elif isinstance(c, ListConfig):
+        assert isinstance(ret_key, str)
+        if not is_int(ret_key):
+            if throw_on_type_error:
+                raise TypeError(
+                    f"Index '{ret_key}' ({type(ret_key).__name__}) is not an int"
+                )
+            else:
+                val = None
+        else:
+            ret_key = int(ret_key)
+            if ret_key < 0 or ret_key + 1 > len(c):
+                val = None
+            else:
+                val = c._get_child(ret_key)
+    else:
+        assert False
+
+    if val is not None:
+        assert isinstance(val, Node)
+        if val._is_missing():
+            if throw_on_missing:
+                raise MissingMandatoryValue(
+                    f"Missing mandatory value: {c._get_full_key(ret_key)}"
+                )
+            else:
+                return val, ret_key
+
+    assert val is None or isinstance(val, Node)
+    return val, ret_key

lib/python3.12/site-packages/omegaconf/version.py

@@ -0,0 +1,13 @@
+import sys  # pragma: no cover
+
+__version__ = "2.3.0"
+
+msg = """OmegaConf 2.0 and above is compatible with Python 3.6 and newer.
+You have the following options:
+1. Upgrade to Python 3.6 or newer.
+   This is highly recommended. new features will not be added to OmegaConf 1.4.
+2. Continue using OmegaConf 1.4:
+    You can pip install 'OmegaConf<1.5' to do that.
+"""
+if sys.version_info < (3, 6):
+    raise ImportError(msg)  # pragma: no cover