omegaconf 2.4.0.dev11__tar.gz → 2.4.0.dev13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omegaconf
-Version: 2.4.0.dev11
+Version: 2.4.0.dev13
 Summary: A flexible configuration library
 Home-page: https://github.com/omry/omegaconf
 Author: Omry Yadan
@@ -57,7 +57,7 @@ Dynamic: summary
 | Project | [![PyPI version](https://badge.fury.io/py/omegaconf.svg)](https://badge.fury.io/py/omegaconf)[![Downloads](https://pepy.tech/badge/omegaconf/month)](https://pepy.tech/project/omegaconf)![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue) |
 | Code quality| [![CircleCI](https://dl.circleci.com/status-badge/img/gh/omry/omegaconf/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/omry/omegaconf/tree/main)[![Coverage Status](https://coveralls.io/repos/github/omry/omegaconf/badge.svg)](https://coveralls.io/github/omry/omegaconf)|
 | Docs and support |[![Documentation Status](https://readthedocs.org/projects/omegaconf/badge/?version=2.0_branch)](https://omegaconf.readthedocs.io/en/2.3_branch/)[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/omry/omegaconf/master?filepath=docs%2Fnotebook%2FTutorial.ipynb)[![Zulip chat](https://img.shields.io/badge/chat-Zulip-2e77d0?logo=zulip)](https://hydra-framework.zulipchat.com/)|
-| Backlog | [Issues & PRs backlog](https://omry.github.io/omegaconf/) |
+| Backlog | [![Backlog Atlas dashboard](https://omry.github.io/backlog-atlas/badge.svg)](https://omry.github.io/backlog-atlas/) |
 
 
 OmegaConf is a hierarchical configuration system, with support for merging configurations from multiple sources (YAML config files, dataclasses/objects and CLI arguments)

{omegaconf-2.4.0.dev11 → omegaconf-2.4.0.dev13}/README.md

@@ -4,7 +4,7 @@
 | Project | [![PyPI version](https://badge.fury.io/py/omegaconf.svg)](https://badge.fury.io/py/omegaconf)[![Downloads](https://pepy.tech/badge/omegaconf/month)](https://pepy.tech/project/omegaconf)![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue) |
 | Code quality| [![CircleCI](https://dl.circleci.com/status-badge/img/gh/omry/omegaconf/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/omry/omegaconf/tree/main)[![Coverage Status](https://coveralls.io/repos/github/omry/omegaconf/badge.svg)](https://coveralls.io/github/omry/omegaconf)|
 | Docs and support |[![Documentation Status](https://readthedocs.org/projects/omegaconf/badge/?version=2.0_branch)](https://omegaconf.readthedocs.io/en/2.3_branch/)[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/omry/omegaconf/master?filepath=docs%2Fnotebook%2FTutorial.ipynb)[![Zulip chat](https://img.shields.io/badge/chat-Zulip-2e77d0?logo=zulip)](https://hydra-framework.zulipchat.com/)|
-| Backlog | [Issues & PRs backlog](https://omry.github.io/omegaconf/) |
+| Backlog | [![Backlog Atlas dashboard](https://omry.github.io/backlog-atlas/badge.svg)](https://omry.github.io/backlog-atlas/) |
 
 
 OmegaConf is a hierarchical configuration system, with support for merging configurations from multiple sources (YAML config files, dataclasses/objects and CLI arguments)

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

@@ -30,6 +30,7 @@ from .omegaconf import (
     open_dict,
     read_write,
 )
+from .tupleconfig import TupleConfig
 from .typing import Antlr4ParserRuleContext
 from .version import __version__
 
@@ -43,6 +44,7 @@ __all__ = [
     "Container",
     "UnionNode",
     "ListConfig",
+    "TupleConfig",
     "DictConfig",
     "DictKeyType",
     "OmegaConf",

{omegaconf-2.4.0.dev11 → omegaconf-2.4.0.dev13}/omegaconf/_impl.py

@@ -1,13 +1,18 @@
 from typing import Any
 
-from omegaconf import Container, DictConfig, ListConfig, Node, ValueNode
-from omegaconf.errors import ConfigKeyError, ConfigTypeError
+from omegaconf import Container, DictConfig, ListConfig, Node, TupleConfig, ValueNode
+from omegaconf.errors import (
+    ConfigKeyError,
+    ConfigTypeError,
+    InterpolationToMissingValueError,
+)
 from omegaconf.nodes import InterpolationResultNode
 
 from ._utils import (
     _DEFAULT_MARKER_,
     _ensure_container,
     _get_value,
+    _is_missing_literal,
     is_primitive_container,
     is_structured_config,
 )
@@ -26,8 +31,19 @@ def _resolve_container_value(cfg: Container, key: Any) -> None:
                 resolved_value
             ):
                 resolved = _ensure_container(resolved_value)
+        if isinstance(cfg, TupleConfig) and _is_missing_literal(_get_value(resolved)):
+            cfg._format_and_raise(
+                key=key,
+                value=_get_value(resolved),
+                cause=InterpolationToMissingValueError(
+                    "TupleConfig interpolation resolved to a missing value"
+                ),
+            )
         if isinstance(resolved, Container) and isinstance(node, ValueNode):
-            cfg[key] = resolved
+            if isinstance(cfg, TupleConfig):
+                cfg._set_item_for_resolution(key, resolved)
+            else:
+                cfg[key] = resolved
         else:
             node._set_value(_get_value(resolved))
     else:
@@ -44,7 +60,7 @@ def _resolve(cfg: Node) -> Node:
         for k in list(cfg.keys()):
             _resolve_container_value(cfg, k)
 
-    elif isinstance(cfg, ListConfig):
+    elif isinstance(cfg, (ListConfig, TupleConfig)):
         for i in range(len(cfg)):
             _resolve_container_value(cfg, i)
 

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

@@ -131,6 +131,7 @@ _DEFAULT_MARKER_: Any = Marker("_DEFAULT_MARKER_")
 class OmegaConfDumper(BaseDumper):  # type: ignore
     str_representer_added = False
     pathlib_representers_added = False
+    tuple_representer_added = False
 
     @staticmethod
     def str_representer(dumper: yaml.Dumper, data: str) -> yaml.ScalarNode:
@@ -166,6 +167,12 @@ class OmegaConfDumper(BaseDumper):  # type: ignore
             [str(data)],
         )
 
+    @staticmethod
+    def tuple_representer(dumper: yaml.Dumper, data: Any) -> yaml.Node:
+        return dumper.represent_sequence(
+            yaml.resolver.BaseResolver.DEFAULT_SEQUENCE_TAG, data
+        )
+
 
 def get_omega_conf_dumper() -> Type[OmegaConfDumper]:
     if not OmegaConfDumper.str_representer_added:
@@ -186,6 +193,10 @@ def get_omega_conf_dumper() -> Type[OmegaConfDumper]:
         )
         OmegaConfDumper.pathlib_representers_added = True
 
+    if not OmegaConfDumper.tuple_representer_added:
+        OmegaConfDumper.add_representer(tuple, OmegaConfDumper.tuple_representer)
+        OmegaConfDumper.tuple_representer_added = True
+
     return OmegaConfDumper
 
 
@@ -340,6 +351,7 @@ def get_attr_class_fields(obj: Any) -> List["AttrAttribute[Any]"]:
 
 
 def get_attr_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, Any]:
+    from omegaconf.base import Node
     from omegaconf.omegaconf import OmegaConf, _maybe_wrap
 
     flags = {"allow_objects": allow_objects} if allow_objects is not None else {}
@@ -377,6 +389,8 @@ def get_attr_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, A
                 value = default.factory()
             else:
                 value = default
+        if isinstance(value, Node):
+            value = copy.deepcopy(value)
         if is_union_annotation(type_) and not is_supported_union_annotation(type_):
             e = ConfigValueError(
                 f"Unions of containers are not supported:\n{name}: {type_str(type_)}"  # noqa: E231
@@ -410,6 +424,7 @@ def get_dataclass_fields(obj: Any) -> List["dataclasses.Field[Any]"]:
 def get_dataclass_data(
     obj: Any, allow_objects: Optional[bool] = None
 ) -> Dict[str, Any]:
+    from omegaconf.base import Node
     from omegaconf.omegaconf import MISSING, OmegaConf, _maybe_wrap
 
     flags = {"allow_objects": allow_objects} if allow_objects is not None else {}
@@ -435,6 +450,8 @@ def get_dataclass_data(
                 value = field.default_factory()  # type: ignore
             else:
                 value = MISSING
+        if isinstance(value, Node):
+            value = copy.deepcopy(value)
 
         if is_union_annotation(type_) and not is_supported_union_annotation(type_):
             e = ConfigValueError(
@@ -736,18 +753,54 @@ def get_list_element_type(ref_type: Optional[Type[Any]]) -> Any:
 
 def get_tuple_item_types(ref_type: Type[Any]) -> Tuple[Any, ...]:
     args = getattr(ref_type, "__args__", None)
-    if args in (None, ()):
+    if ref_type in (tuple, Tuple) or args is None:
         args = (Any, ...)
+    elif args == ((),):
+        args = ()
     assert isinstance(args, tuple)
     return args
 
 
+def normalize_tuple_annotation(ref_type: Any) -> Any:
+    if not is_tuple_annotation(ref_type):
+        raise ValidationError(f"Unsupported tuple type: '{type_str(ref_type)}'")
+
+    if ref_type in (tuple, Tuple):
+        return Tuple[Any, ...]
+
+    args = get_tuple_item_types(ref_type)
+    if Ellipsis in args and not (len(args) == 2 and args[1] is Ellipsis):
+        raise ValidationError(f"Unsupported tuple type: '{type_str(ref_type)}'")
+
+    for item_type in args:
+        origin = getattr(item_type, "__origin__", None)
+        if (
+            getattr(origin, "__module__", None),
+            getattr(origin, "__qualname__", None),
+        ) in (("typing", "Unpack"), ("typing_extensions", "Unpack")):
+            raise ValidationError(f"Unsupported tuple type: '{type_str(ref_type)}'")
+
+    return ref_type
+
+
+def is_variadic_tuple_annotation(ref_type: Any) -> bool:
+    args = get_tuple_item_types(normalize_tuple_annotation(ref_type))
+    return len(args) == 2 and args[1] is Ellipsis
+
+
+def make_tuple_annotation(item_types: Tuple[Any, ...]) -> Any:
+    return Tuple[item_types]  # type: ignore[valid-type]
+
+
 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)
+            for base in bases:
+                if is_dict_annotation(base):
+                    args = getattr(base, "__args__", None)
+                    break
 
     key_type: Any
     element_type: Any
@@ -755,7 +808,7 @@ def get_dict_key_value_types(ref_type: Any) -> Tuple[Any, Any]:
         key_type = Any
         element_type = Any
     else:
-        if args is not None:
+        if args is not None and len(args) == 2:
             key_type = args[0]
             element_type = args[1]
         else:
@@ -829,12 +882,16 @@ def get_type_hint(obj: Any, key: Any = None) -> Optional[Type[Any]]:
         return Any  # type: ignore
 
 
-def _raise(ex: Exception, cause: Exception) -> None:
+def _is_full_backtrace_enabled() -> bool:
     # 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")
+    return (debugging and not env_var == "0") or (env_var == "1")
+
+
+def _raise(ex: Exception, cause: Exception) -> None:
+    full_backtrace = _is_full_backtrace_enabled()
     if full_backtrace:
         # In the alias case (`cause is ex`), assigning `ex.__cause__ = cause`
         # would create a self-reference cycle that pins `ex` (and transitively
@@ -845,9 +902,12 @@ def _raise(ex: Exception, cause: Exception) -> None:
     else:
         ex.__cause__ = None
     try:
-        raise ex.with_traceback(
-            sys.exc_info()[2]
-        )  # set env var OC_CAUSE=1 for full trace
+        # Set env var OC_CAUSE=1 for full trace. In normal mode, avoid
+        # preserving the active traceback because it can retain caller frame
+        # locals until cyclic GC runs.
+        if full_backtrace:
+            raise ex.with_traceback(sys.exc_info()[2])
+        raise ex.with_traceback(None) from None
     finally:
         # Follow https://peps.python.org/pep-3110/ to break
         # the exception reference cycle.
@@ -1027,14 +1087,14 @@ def _ensure_container(target: Any, flags: Optional[Dict[str, bool]] = None) -> A
     from omegaconf import OmegaConf
 
     if is_primitive_container(target):
-        assert isinstance(target, (list, dict))
+        assert isinstance(target, (list, tuple, 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]"
+            + "[dict,list,tuple,DictConfig,ListConfig,TupleConfig,dataclass,dataclass instance,attr class,attr class instance]"
         )
 
     return target
@@ -1067,7 +1127,11 @@ def is_generic_dict(type_: Any) -> bool:
 
 
 def is_container_annotation(type_: Any) -> bool:
-    return is_list_annotation(type_) or is_dict_annotation(type_)
+    return (
+        is_list_annotation(type_)
+        or is_tuple_annotation(type_)
+        or is_dict_annotation(type_)
+    )
 
 
 # Characters recognised after a backslash in key paths and dotlist entries.

{omegaconf-2.4.0.dev11 → omegaconf-2.4.0.dev13}/omegaconf/base.py

@@ -22,6 +22,7 @@ from ._utils import (
     NoneType,
     ValueKind,
     _get_value,
+    _is_full_backtrace_enabled,
     _is_interpolation,
     _is_missing_value,
     _is_special,
@@ -29,6 +30,7 @@ from ._utils import (
     get_value_kind,
     is_dict_annotation,
     is_list_annotation,
+    is_tuple_annotation,
     is_union_annotation,
     is_valid_value_annotation,
     split_key,
@@ -42,6 +44,7 @@ from .errors import (
     InterpolationToMissingValueError,
     InterpolationValidationError,
     MissingMandatoryValue,
+    OmegaConfBaseException,
     UnsupportedInterpolationType,
     ValidationError,
 )
@@ -238,6 +241,17 @@ class Node(ABC):
         msg: Optional[str] = None,
         type_override: Any = None,
     ) -> NoReturn:
+        if (
+            type_override is None
+            and isinstance(cause, OmegaConfBaseException)
+            and cause._initialized
+        ):
+            if not _is_full_backtrace_enabled():
+                cause.__traceback__ = None
+                cause.__context__ = None
+            # Keep the re-raise in this common wrapper so callers do not need
+            # to remember traceback cleanup before forwarding OmegaConf errors.
+            raise
         format_and_raise(
             node=self,
             key=key,
@@ -364,7 +378,7 @@ class Node(ABC):
 class Box(Node):
     """
     Base class for nodes that can contain other nodes.
-    Concrete subclasses include DictConfig, ListConfig, and UnionNode.
+    Concrete subclasses include DictConfig, ListConfig, TupleConfig, and UnionNode.
     """
 
     _content: Any
@@ -380,6 +394,7 @@ class Box(Node):
     def _re_parent(self) -> None:
         from .dictconfig import DictConfig
         from .listconfig import ListConfig
+        from .tupleconfig import TupleConfig
 
         # update parents of first level Config nodes to self
 
@@ -391,7 +406,7 @@ class Box(Node):
                         value._set_parent(self)
                     if isinstance(value, Box):
                         value._re_parent()
-        elif isinstance(self, ListConfig):
+        elif isinstance(self, (ListConfig, TupleConfig)):
             content = self.__dict__["_content"]
             if isinstance(content, list):
                 for item in self.__dict__["_content"]:
@@ -690,6 +705,7 @@ class Container(Box):
         resolved_node_cache: Optional[Dict[int, "Node"]] = None,
     ) -> "Node":
         """A node interpolation is of the form `${foo.bar}`"""
+        original_inter_key = inter_key
         try:
             root_node, inter_key = self._resolve_key_and_root(inter_key)
         except ConfigKeyError as exc:
@@ -711,7 +727,19 @@ class Container(Box):
             ).with_traceback(sys.exc_info()[2])
 
         if parent is None or value is None:
-            raise InterpolationKeyError(f"Interpolation key '{inter_key}' not found")
+            msg = f"Interpolation key '{inter_key}' not found"
+            if original_inter_key != inter_key:
+                try:
+                    resolved_inter_key = root_node._get_full_key(inter_key)
+                except Exception as exc:
+                    resolved_inter_key = (
+                        f"<unresolvable due to {type(exc).__name__}: {exc}>"
+                    )
+                msg = (
+                    f"Interpolation key '{original_inter_key}' not found"
+                    f" (resolved to '{resolved_inter_key}')"
+                )
+            raise InterpolationKeyError(msg)
         else:
             self._validate_not_dereferencing_to_parent(node=self, target=value)
             return value
@@ -818,6 +846,7 @@ class Container(Box):
     def _invalidate_flags_cache(self) -> None:
         from .dictconfig import DictConfig
         from .listconfig import ListConfig
+        from .tupleconfig import TupleConfig
 
         # invalidate subtree cache only if the cache is initialized in this node.
 
@@ -828,7 +857,7 @@ class Container(Box):
                 if isinstance(content, dict):
                     for value in self.__dict__["_content"].values():
                         value._invalidate_flags_cache()
-            elif isinstance(self, ListConfig):
+            elif isinstance(self, (ListConfig, TupleConfig)):
                 content = self.__dict__["_content"]
                 if isinstance(content, list):
                     for item in self.__dict__["_content"]:
@@ -943,6 +972,7 @@ class UnionNode(Box):
     ) -> None:
         from omegaconf.listconfig import ListConfig
         from omegaconf.omegaconf import _node_wrap
+        from omegaconf.tupleconfig import TupleConfig
 
         ref_type = self._metadata.ref_type
         type_hint = self._metadata.type_hint
@@ -956,12 +986,25 @@ class UnionNode(Box):
                         f"Value '$VALUE' is incompatible with type hint '{type_str(type_hint)}'"
                     )
             self.__dict__["_content"] = value
-        elif isinstance(value, (list, tuple, ListConfig)):
-            # Only try List[...] candidates — keeps primitive members out of container
-            # dispatch and makes ambiguity an error instead of silent first-match.
+        elif isinstance(value, (list, tuple, ListConfig, TupleConfig)):
+            sequence_candidates = [
+                t
+                for t in ref_type.__args__
+                if is_list_annotation(t) or is_tuple_annotation(t)
+            ]
+            input_is_tuple = isinstance(value, (tuple, TupleConfig))
+            preferred_candidates = [
+                t
+                for t in sequence_candidates
+                if is_tuple_annotation(t) == input_is_tuple
+            ]
+            fallback_candidates = [
+                t for t in sequence_candidates if t not in preferred_candidates
+            ]
             self._set_container_value(
                 value=value,
-                candidates=[t for t in ref_type.__args__ if is_list_annotation(t)],
+                candidates=preferred_candidates,
+                fallback_candidates=fallback_candidates,
                 type_hint=type_hint,
             )
         elif isinstance(value, (dict, Container)):
@@ -994,48 +1037,79 @@ class UnionNode(Box):
         value: Any,
         candidates: List[Any],
         type_hint: Any,
+        fallback_candidates: Optional[List[Any]] = None,
     ) -> None:
         from omegaconf.listconfig import ListConfig
         from omegaconf.omegaconf import _node_wrap
+        from omegaconf.tupleconfig import TupleConfig
 
-        from ._utils import get_dict_key_value_types, get_list_element_type
+        from ._utils import (
+            get_dict_key_value_types,
+            get_list_element_type,
+            get_tuple_item_types,
+            normalize_tuple_annotation,
+        )
 
         # For an already-typed container (from typed_list/typed_dict or another
         # structured config), use its element-type metadata to narrow candidates
         # before falling back to content-based validation. This makes empty
         # containers unambiguous when the metadata uniquely identifies one branch.
-        if isinstance(value, ListConfig) and value._metadata.element_type is not Any:
-            meta_candidates = [
-                t
-                for t in candidates
-                if get_list_element_type(t) == value._metadata.element_type
-            ]
-            if meta_candidates:
-                candidates = meta_candidates
-        elif isinstance(value, Container) and not isinstance(value, ListConfig):
-            vkey, vval = get_dict_key_value_types(value._metadata.ref_type)
-            if vkey is not Any or vval is not Any:
+        def narrow_by_metadata(candidate_types: List[Any]) -> List[Any]:
+            meta_candidates: List[Any] = []
+            if (
+                isinstance(value, ListConfig)
+                and value._metadata.element_type is not Any
+            ):
                 meta_candidates = [
-                    t for t in candidates if get_dict_key_value_types(t) == (vkey, vval)
+                    t
+                    for t in candidate_types
+                    if is_list_annotation(t)
+                    and get_list_element_type(t) == value._metadata.element_type
                 ]
-                if meta_candidates:
-                    candidates = meta_candidates
+            elif isinstance(value, TupleConfig):
+                value_type = normalize_tuple_annotation(value._metadata.ref_type)
+                value_item_types = get_tuple_item_types(value_type)
+                meta_candidates = [
+                    t
+                    for t in candidate_types
+                    if is_tuple_annotation(t)
+                    and get_tuple_item_types(normalize_tuple_annotation(t))
+                    == value_item_types
+                ]
+            elif isinstance(value, Container) and not isinstance(
+                value, (ListConfig, TupleConfig)
+            ):
+                vkey, vval = get_dict_key_value_types(value._metadata.ref_type)
+                if vkey is not Any or vval is not Any:
+                    meta_candidates = [
+                        t
+                        for t in candidate_types
+                        if is_dict_annotation(t)
+                        and get_dict_key_value_types(t) == (vkey, vval)
+                    ]
+            return meta_candidates or candidate_types
+
+        def find_matches(candidate_types: List[Any]) -> List[Node]:
+            matches: List[Node] = []
+            for candidate_ref_type in narrow_by_metadata(candidate_types):
+                try:
+                    node = _node_wrap(
+                        value=value,
+                        ref_type=candidate_ref_type,
+                        is_optional=False,
+                        key=None,
+                        parent=self,
+                    )
+                    matches.append(node)
+                    if len(matches) > 1:
+                        break
+                except Exception:
+                    continue
+            return matches
 
-        matches: List[Node] = []
-        for candidate_ref_type in candidates:
-            try:
-                node = _node_wrap(
-                    value=value,
-                    ref_type=candidate_ref_type,
-                    is_optional=False,
-                    key=None,
-                    parent=self,
-                )
-                matches.append(node)
-                if len(matches) > 1:
-                    break  # ambiguous — stop constructing further candidates
-            except Exception:
-                continue
+        matches = find_matches(candidates)
+        if len(matches) == 0 and fallback_candidates:
+            matches = find_matches(fallback_candidates)
 
         if len(matches) == 0:
             raise ValidationError(