omegaconf 2.4.0.dev14__tar.gz → 2.4.0.dev15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omegaconf
-Version: 2.4.0.dev14
+Version: 2.4.0.dev15
 Summary: A flexible configuration library
 Home-page: https://github.com/omry/omegaconf
 Author: Omry Yadan

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/omegaconf/_impl.py

@@ -22,7 +22,13 @@ def _resolve_container_value(cfg: Container, key: Any) -> None:
     node = cfg._get_child(key)
     assert isinstance(node, Node)
     if node._is_interpolation():
-        resolved = node._dereference_node()
+        try:
+            resolved = node._dereference_node()
+        except Exception as e:
+            # Attach the same key/object_type context that direct node access
+            # reports, so errors surfaced through OmegaConf.resolve() stay
+            # diagnosable.
+            cfg._format_and_raise(key=key, value=None, cause=e)
         if isinstance(resolved, Container):
             _resolve(resolved)
         if isinstance(resolved, InterpolationResultNode):

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/omegaconf/basecontainer.py

@@ -417,16 +417,17 @@ class BaseContainer(Container, ABC):
                 ref_type=src_ref_type, object_type=src_type
             )
 
-        if dest._is_interpolation() and src_was_missing_structured:
-            # Keep unresolved structured interpolations intact when the source
-            # was originally MISSING; the synthesized prototype only exists to
-            # preserve type information during merge.
+        if (dest._is_interpolation() or dest._is_none()) and src_was_missing_structured:
+            # Keep unresolved structured interpolations and null values intact
+            # when the source was originally MISSING; the synthesized prototype
+            # only exists to preserve type information during merge.
             _update_types(node=dest, ref_type=src_ref_type, object_type=src_type)
             return
 
         if (
             (dest._is_interpolation() and not src_was_missing_structured)
             or dest._is_missing()
+            or dest._is_none()
         ) and not src._is_missing():
             expand(dest)
 

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/omegaconf/dictconfig.py

@@ -34,6 +34,7 @@ from ._utils import (
     get_value_kind,
     is_container_annotation,
     is_dict,
+    is_int,
     is_primitive_dict,
     is_structured_config,
     is_structured_config_frozen,
@@ -69,6 +70,7 @@ def _make_key_suggestion(key: Any, available: Iterable) -> str:
 class DictConfig(BaseContainer, MutableMapping[Any, Any]):
     _metadata: ContainerMetadata
     _content: Union[Dict[DictKeyType, Node], None, str]
+    __hash__ = None  # type: ignore[assignment]
 
     def __init__(
         self,
@@ -227,6 +229,8 @@ class DictConfig(BaseContainer, MutableMapping[Any, Any]):
         self._validate_non_optional(None, src)
 
         dest_obj_type = OmegaConf.get_type(dest)
+        if dest._is_none() and is_structured_config(dest._metadata.ref_type):
+            dest_obj_type = dest._metadata.ref_type
         src_obj_type = OmegaConf.get_type(src)
 
         if dest._is_missing() and src._metadata.object_type not in (dict, None):
@@ -334,8 +338,34 @@ class DictConfig(BaseContainer, MutableMapping[Any, Any]):
 
     def __set_impl(self, key: DictKeyType, value: Any) -> None:
         key = self._validate_and_normalize_key(key)
+        self._validate_non_ambiguous_key(key)
         self._set_item_impl(key, value)
 
+    def _validate_non_ambiguous_key(self, key: DictKeyType) -> None:
+        content = self.__dict__["_content"]
+        if self._metadata.key_type is not Any or not isinstance(content, dict):
+            return
+
+        conflicting_key: Optional[DictKeyType] = None
+        if isinstance(key, str) and is_int(key):
+            numeric_key = int(key)
+            node = content.get(numeric_key)
+            if (
+                str(numeric_key) == key
+                and isinstance(node, Node)
+                and type(node._key()) is int
+            ):
+                conflicting_key = numeric_key
+        elif type(key) is int and str(key) in content:
+            node = content.get(key)
+            if not isinstance(node, Node) or type(node._key()) is int:
+                conflicting_key = str(key)
+
+        if conflicting_key is not None:
+            raise KeyValidationError(
+                f"Conflicting integer and string keys: {conflicting_key!r} and {key!r}"
+            )
+
     # hide content while inspecting in debugger
     def __dir__(self) -> Iterable[str]:
         if self._is_missing() or self._is_none():
@@ -634,9 +664,6 @@ class DictConfig(BaseContainer, MutableMapping[Any, Any]):
             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.

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/omegaconf/grammar_visitor.py

@@ -86,10 +86,12 @@ class GrammarVisitor(OmegaConfGrammarParserVisitor):
         if isinstance(child, OmegaConfGrammarParser.InterpolationContext):
             child_text = child.getText()
             res = _get_value(self.visitInterpolation(child))
-            if not isinstance(res, str):
+            if type(res) is int:
+                return str(res)
+            elif 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"thus should return a string or integer, but instead returned `{res}` of "
                     f"type `{type(res)}`: {child_text}"
                 )
             return res

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/omegaconf/listconfig.py

@@ -47,6 +47,7 @@ from .errors import (
 
 class ListConfig(BaseContainer, MutableSequence[Any]):
     _content: Union[List[Node], None, str]
+    __hash__ = None  # type: ignore[assignment]
 
     def __init__(
         self,
@@ -523,9 +524,6 @@ class ListConfig(BaseContainer, MutableSequence[Any]):
             return not x
         return NotImplemented
 
-    def __hash__(self) -> int:
-        return hash(str(self))
-
     def __iter__(self) -> Iterator[Any]:
         return self._iter_ex(resolve=True)
 

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/omegaconf/omegaconf.py

@@ -1423,7 +1423,9 @@ class OmegaConf:
         )
 
         last_key: Union[str, int] = last
-        if OmegaConf.is_sequence(root):
+        if OmegaConf.is_dict(root):
+            _, last_key = _select_one(root, last, throw_on_missing=False)
+        elif OmegaConf.is_sequence(root):
             last_key = int(last)
 
         ctx = flag_override(root, "struct", False) if force_add else nullcontext()
@@ -1438,8 +1440,10 @@ class OmegaConf:
                         return
 
             if OmegaConf.is_dict(root):
-                assert isinstance(last_key, str)
-                root.__setattr__(last_key, value)
+                if isinstance(last_key, int):
+                    root.__setitem__(last_key, value)
+                else:
+                    root.__setattr__(last_key, value)
             elif OmegaConf.is_sequence(root):
                 assert isinstance(last_key, int)
                 root.__setitem__(last_key, value)
@@ -1973,6 +1977,14 @@ def _select_one(
     if isinstance(c, DictConfig):
         assert isinstance(ret_key, str)
         val = c._get_child(ret_key, validate_access=False)
+        if val is None and is_int(ret_key):
+            numeric_key = int(ret_key)
+            raw_node = c._get_node(numeric_key, validate_access=False)
+            if isinstance(raw_node, Node) and type(raw_node._key()) is int:
+                val = c._get_child(numeric_key, validate_access=False)
+                ret_key = numeric_key
+            else:
+                val = None
     elif isinstance(c, (ListConfig, TupleConfig)):
         assert isinstance(ret_key, str)
         if not is_int(ret_key):

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/omegaconf/version.py

@@ -1,7 +1,7 @@
 import sys  # pragma: no cover
 
 # Managed by bump-my-version; see pyproject.toml for bump commands.
-__version__ = "2.4.0.dev14"
+__version__ = "2.4.0.dev15"
 
 msg = """OmegaConf 2.4 and above is compatible with Python 3.10 and newer.
 You have the following options:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omegaconf
-Version: 2.4.0.dev14
+Version: 2.4.0.dev15
 Summary: A flexible configuration library
 Home-page: https://github.com/omry/omegaconf
 Author: Omry Yadan

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/pyproject.toml

@@ -29,7 +29,7 @@ norecursedirs = ["subprojects", ".git", ".sl", ".venv"]
 # Version source of truth. Use bump-my-version so configured files stay in sync.
 # `bump-my-version bump pre_n` updates 2.4.0.dev13 to 2.4.0.dev14.
 # `bump-my-version bump --new-version 2.4.0` sets the final release version.
-current_version = "2.4.0.dev14"
+current_version = "2.4.0.dev15"
 parse = '''(?x)
     (?P<major>\d+)
     \.(?P<minor>\d+)

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/tests/interpolation/test_interpolation.py

@@ -2,7 +2,7 @@ import copy
 import re
 from pathlib import Path
 from textwrap import dedent
-from typing import Any, Tuple
+from typing import Any, Tuple, Union
 
 from pytest import mark, param, raises
 
@@ -214,6 +214,59 @@ def test_interpolation_after_copy(copy_func: Any, data: Any, key: Any) -> None:
     assert copy_func(dict_cfg._get_node(key))._dereference_node() == 10
 
 
+@mark.parametrize("key", [param(1, id="int"), param("1", id="str")])
+def test_interpolation_to_integer_key(key: Any) -> None:
+    cfg = OmegaConf.create({key: "value", "ref": "${1}"})
+
+    assert cfg.ref == "value"
+
+
+@mark.parametrize("resolution", [param(224, id="int"), param("224", id="str")])
+def test_interpolation_with_nested_integer_key(resolution: Any) -> None:
+    cfg = OmegaConf.create(
+        {
+            "anchors": {"imagenet": {resolution: {"data": "value"}}},
+            "dataset": "imagenet",
+            "resolution": 224,
+            "ref": "${anchors.${dataset}.${resolution}.data}",
+        }
+    )
+
+    assert cfg.ref == "value"
+
+
+def test_interpolation_with_nested_integer_key_from_yaml() -> None:
+    cfg = OmegaConf.create(
+        dedent(
+            """
+            anchors:
+              coco2014:
+                224:
+                  data: [1, 2, 3]
+            dataset: coco2014
+            resolution: 224
+            ref: ${anchors.${dataset}.${resolution}.data}
+            """
+        )
+    )
+
+    assert cfg.ref == [1, 2, 3]
+
+
+def test_interpolation_to_typed_integer_key() -> None:
+    values = DictConfig({1: "value"}, key_type=int)
+    cfg = OmegaConf.create({"values": values, "ref": "${values.1}"})
+
+    assert cfg.ref == "value"
+
+
+def test_interpolation_to_union_typed_integer_key() -> None:
+    values = DictConfig({1: 10}, element_type=Union[int, str])
+    cfg = OmegaConf.create({"values": values, "ref": "${values.1}"})
+
+    assert cfg.ref == 10
+
+
 def test_resolve_interpolation_without_parent() -> None:
     with raises(
         IRE, match=re.escape("Cannot resolve interpolation for a node without a parent")

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/tests/test_basic_ops_dict.py

@@ -871,12 +871,13 @@ def test_dir(cfg: Any, key: Any, expected: Any) -> None:
         assert dir(c._get_node(key)) == expected
 
 
-def test_hash() -> None:
-    c1 = OmegaConf.create({"a": 10})
-    c2 = OmegaConf.create({"a": 10})
-    assert hash(c1) == hash(c2)
-    c2.a = 20
-    assert hash(c1) != hash(c2)
+def test_unhashable() -> None:
+    cfg = OmegaConf.create({"a": 10})
+    with raises(TypeError, match="unhashable"):
+        hash(cfg)
+    OmegaConf.set_readonly(cfg, True)
+    with raises(TypeError, match="unhashable"):
+        hash(cfg)
 
 
 @mark.parametrize("default", ["default", 0, None])
@@ -988,6 +989,49 @@ def test_creation_with_invalid_key() -> None:
         OmegaConf.create({object(): "a"})
 
 
+@mark.parametrize(
+    "items",
+    [
+        param([(1, "numeric"), ("1", "string")], id="int-first"),
+        param([("1", "string"), (1, "numeric")], id="str-first"),
+    ],
+)
+def test_creation_with_ambiguous_integer_key(items: Any) -> None:
+    with raises(KeyValidationError, match="integer and string keys"):
+        OmegaConf.create(dict(items))
+
+
+@mark.parametrize(
+    ("initial_key", "new_key"),
+    [param(1, "1", id="int-first"), param("1", 1, id="str-first")],
+)
+def test_setitem_with_ambiguous_integer_key(initial_key: Any, new_key: Any) -> None:
+    cfg = OmegaConf.create({initial_key: "initial"})
+
+    with raises(KeyValidationError, match="integer and string keys"):
+        cfg[new_key] = "new"
+
+
+def test_float_and_string_keys_are_not_ambiguous() -> None:
+    cfg = OmegaConf.create({1.5: "float", "1.5": "string"})
+
+    assert cfg[1.5] == "float"
+    assert cfg["1.5"] == "string"
+
+
+@mark.parametrize("stored_key", [param(True, id="bool"), param(1.0, id="float")])
+def test_setitem_integer_key_updates_equal_non_integer_key(stored_key: Any) -> None:
+    cfg = OmegaConf.create({stored_key: "initial", "1": "string"})
+
+    cfg[1] = "updated"
+
+    assert cfg[stored_key] == "updated"
+    assert cfg["1"] == "string"
+    node = cfg._get_node(stored_key)
+    assert node is not None
+    assert type(node._key()) is type(stored_key)
+
+
 def test_setitem_with_invalid_key() -> None:
     cfg = OmegaConf.create()
     with raises(KeyValidationError):

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/tests/test_basic_ops_list.py

@@ -858,12 +858,13 @@ def test_append_throws_not_changing_list() -> None:
     assert c == [iv]
 
 
-def test_hash() -> None:
-    c1 = OmegaConf.create([10])
-    c2 = OmegaConf.create([10])
-    assert hash(c1) == hash(c2)
-    c2[0] = 20
-    assert hash(c1) != hash(c2)
+def test_unhashable() -> None:
+    cfg = OmegaConf.create([10])
+    with raises(TypeError, match="unhashable"):
+        hash(cfg)
+    OmegaConf.set_readonly(cfg, True)
+    with raises(TypeError, match="unhashable"):
+        hash(cfg)
 
 
 @mark.parametrize(

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/tests/test_merge.py

@@ -459,6 +459,63 @@ def test_merge(
             merge_function(*configs)
 
 
+@mark.parametrize("merge", [OmegaConf.merge, OmegaConf.unsafe_merge])
+@mark.parametrize(
+    ("override", "expected_count"),
+    [param({}, 10, id="empty"), param({"count": 20}, 20, id="non-empty")],
+)
+def test_merge_none_structured_config_root(
+    merge: Any, override: Dict[str, Any], expected_count: int
+) -> None:
+    class RuntimeObject: ...
+
+    @dataclass
+    class Value:
+        count: int = 10
+        inherited: int = "${..template}"  # type: ignore[assignment]
+        payload: Any = field(default_factory=RuntimeObject)
+
+    @dataclass
+    class Config:
+        template: int = 30
+        value: Optional[Value] = None
+
+    cfg = OmegaConf.structured(Config, flags={"allow_objects": True})
+    value = cfg._get_node("value")
+
+    result = merge(value, override)
+
+    assert OmegaConf.get_type(result) is Value
+    assert result.count == expected_count
+    assert result.inherited == 30
+    assert isinstance(result.payload, RuntimeObject)
+    assert result._get_flag("allow_objects") is True
+    assert result._key() == "value"
+
+
+def test_merge_none_structured_config_root_rejects_incompatible_type() -> None:
+    destination = OmegaConf.structured(C)._get_node("x")
+    source = OmegaConf.structured(B)
+
+    with raises(ValidationError):
+        OmegaConf.merge(destination, source)
+
+
+def test_merge_missing_structured_config_into_none_root() -> None:
+    destination = OmegaConf.structured(C)._get_node("x")
+    source = OmegaConf.structured(B)._get_node("x")
+
+    result = OmegaConf.merge(destination, source)
+
+    assert result._is_none()
+
+
+def test_merge_none_dictconfig_root() -> None:
+    result = OmegaConf.merge(DictConfig(None), {"key": "value"})
+
+    assert result == {"key": "value"}
+
+
 def test_merge_missing_structured_keeps_interpolation_target() -> None:
     @dataclass
     class Defaults:

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/tests/test_omegaconf.py

@@ -572,6 +572,21 @@ def test_resolve_raises_on_resolver_arg_to_missing(restore_resolvers: Any) -> No
         OmegaConf.resolve(cfg)
 
 
+def test_resolve_error_keeps_key_and_object_type() -> None:
+    """https://github.com/omry/omegaconf/issues/1330"""
+    cfg = OmegaConf.structured(StructuredWithMissing)
+    cfg.num = "${no_such_key}"
+
+    with raises(InterpolationKeyError) as direct:
+        cfg.num
+    with raises(InterpolationKeyError) as resolved:
+        OmegaConf.resolve(cfg)
+
+    assert resolved.value.full_key == direct.value.full_key == "num"
+    assert direct.value.object_type is StructuredWithMissing
+    assert resolved.value.object_type is StructuredWithMissing
+
+
 def test_resolve_does_not_raise_when_resolver_returns_dict_config(
     restore_resolvers: Any,
 ) -> None:

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/tests/test_select.py

@@ -1,5 +1,5 @@
 from contextlib import AbstractContextManager
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 from pytest import mark, param, raises, warns
 
@@ -7,6 +7,7 @@ from omegaconf import DictConfig, ListConfig, MissingMandatoryValue, OmegaConf
 from omegaconf._impl import select_value
 from omegaconf._utils import _ensure_container
 from omegaconf.errors import InterpolationKeyError
+from tests import Color
 
 
 def _register_resolver(register_func: Any, name: str, resolver: Any) -> None:
@@ -35,6 +36,16 @@ class TestSelect:
             param({"a": ListConfig(None)}, "a.b", None, id="dict:nesting_into_none"),
             # value returned
             param({"c": 1}, "c", 1, id="dict:int"),
+            param({1: "one"}, "1", "one", id="dict:integer-key"),
+            param(
+                DictConfig({1: 10}, element_type=Union[int, str]),
+                "1",
+                10,
+                id="dict:union-typed-integer-key",
+            ),
+            param({True: "bool"}, "1", None, id="dict:bool-key-not-coerced"),
+            param({1.5: "float"}, r"1\.5", None, id="dict:float-key-not-coerced"),
+            param({Color.RED: "red"}, "RED", None, id="dict:enum-key-not-coerced"),
             param({"a": {"v": 1}}, "a.v", 1, id="dict:int"),
             param({"a": {"v": 1}}, "a", {"v": 1}, id="dict:dict"),
             param({"missing": "???"}, "missing", None, id="dict:missing"),
@@ -88,6 +99,12 @@ class TestSelect:
         else:
             assert OmegaConf.select(cfg, key) == expected
 
+    def test_can_select_integer_key(self, struct: Optional[bool]) -> None:
+        cfg = _ensure_container({1: "one"})
+        OmegaConf.set_struct(cfg, struct)
+
+        assert OmegaConf.can_select(cfg, "1")
+
     @mark.parametrize(
         "register_func",
         [OmegaConf.legacy_register_resolver, OmegaConf.register_resolver],

{omegaconf-2.4.0.dev14 → omegaconf-2.4.0.dev15}/tests/test_update.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Union
 
 from pytest import mark, param, raises
 
@@ -18,6 +18,7 @@ from tests import Group, Package, User
     [
         # dict
         param({"a": "b"}, "a", "c", {"a": "c"}, id="replace:string"),
+        param({1: "old"}, "1", "new", {1: "new"}, id="replace:integer-key"),
         param({"a": "b"}, "c", "d", {"a": "b", "c": "d"}, id="add:string"),
         param({"a": "b"}, "c", None, {"a": "b", "c": None}, id="none_value"),
         param({}, "a", {}, {"a": {}}, id="dict:value:empty_dict"),
@@ -56,6 +57,13 @@ from tests import Group, Package, User
             {"a": {"b": 1, "c": 2}},
             id="dict_value:merge",
         ),
+        param(
+            {1: {"a": 1}},
+            "1",
+            {"b": 2},
+            {1: {"a": 1, "b": 2}},
+            id="dict_value:integer-key:merge",
+        ),
         # list
         param({"a": [1, 2]}, "a", [2, 3], {"a": [2, 3]}, id="list:replace"),
         param([1, 2, 3], "1", "abc", [1, "abc", 3], id="list:update"),
@@ -193,6 +201,14 @@ def test_update_list_index_error() -> None:
     assert c == [1, 2, 3]
 
 
+def test_update_union_typed_integer_key() -> None:
+    cfg = DictConfig({1: 10}, element_type=Union[int, str])
+
+    OmegaConf.update(cfg, "1", 20)
+
+    assert cfg == {1: 20}
+
+
 def test_update_merge_by_default() -> None:
     cfg = OmegaConf.create({"a": {"b": 10}})
     OmegaConf.update(cfg, "a", {"c": 20})