678 select

news/678.bugfix

@@ -0,0 +1 @@
+OmegaConf.select now returns None when attempting to select a child of a value or None node

omegaconf/_impl.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 from omegaconf import MISSING, Container, DictConfig, ListConfig, Node, ValueNode
-from omegaconf.errors import ConfigKeyError, InterpolationToMissingValueError
+from omegaconf.errors import ConfigTypeError, InterpolationToMissingValueError
 
 from ._utils import _DEFAULT_MARKER_, _get_value
 
@@ -94,11 +94,11 @@ def select_node(
             throw_on_missing=throw_on_missing,
             throw_on_resolution_failure=throw_on_resolution_failure,
         )
-    except ConfigKeyError:
+    except ConfigTypeError:
         if default is not _DEFAULT_MARKER_:
             return default
         else:
-            raise
+            return None
 
     if (
         default is not _DEFAULT_MARKER_

omegaconf/base.py

@@ -19,6 +19,7 @@
 )
 from .errors import (
     ConfigKeyError,
+    ConfigTypeError,
     InterpolationKeyError,
     InterpolationResolutionError,
     InterpolationToMissingValueError,
@@ -399,7 +400,7 @@ def _select_impl(
             if ret is not None and not isinstance(ret, Container):
                 parent_key = ".".join(split[0 : i + 1])
                 child_key = split[i + 1]
-                raise ConfigKeyError(
+                raise ConfigTypeError(
                     f"Error trying to access {key}: node `{parent_key}` "
                     f"is not a container and thus cannot contain `{child_key}`"
                 )
@@ -610,10 +611,6 @@ def _resolve_node_interpolation(
             raise InterpolationToMissingValueError(
                 f"MissingMandatoryValue while resolving interpolation: {exc}"
             ).with_traceback(sys.exc_info()[2])
-        except ConfigKeyError as exc:
-            raise InterpolationKeyError(
-                f"ConfigKeyError 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")

omegaconf/omegaconf.py

@@ -1047,7 +1047,10 @@ def _select_one(
     from .listconfig import ListConfig
 
     ret_key: Union[str, int] = key
-    assert isinstance(c, (DictConfig, ListConfig)), f"Unexpected type: {c}"
+    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_node(ret_key, validate_access=False)

tests/interpolation/test_interpolation.py

@@ -18,6 +18,7 @@
 )
 from omegaconf._utils import _ensure_container
 from omegaconf.errors import InterpolationKeyError
+from omegaconf.errors import InterpolationResolutionError
 from omegaconf.errors import InterpolationResolutionError as IRE
 from omegaconf.errors import InterpolationValidationError
 from tests import MissingDict, MissingList, StructuredWithMissing, SubscriptedList, User
@@ -85,7 +86,7 @@ def test_merge_with_interpolation() -> None:
 
 def test_non_container_interpolation() -> None:
     cfg = OmegaConf.create({"foo": 0, "bar": "${foo.baz}"})
-    with raises(InterpolationKeyError):
+    with raises(InterpolationResolutionError):
         cfg.bar
 
 

tests/test_errors.py

@@ -280,9 +280,9 @@ def finalize(self, cfg: Any) -> None:
         Expected(
             create=lambda: OmegaConf.create({"foo": "${int.missing}", "int": 0}),
             op=lambda cfg: getattr(cfg, "foo"),
-            exception_type=InterpolationKeyError,
+            exception_type=InterpolationResolutionError,
             msg=(
-                "ConfigKeyError while resolving interpolation: Error trying to access int.missing: "
+                "ConfigTypeError raised while resolving interpolation: Error trying to access int.missing: "
                 "node `int` is not a container and thus cannot contain `missing`"
             ),
             key="foo",

tests/test_select.py

@@ -1,27 +1,28 @@
-import re
 from typing import Any, Optional
 
 from _pytest.python_api import RaisesContext
 from pytest import mark, param, raises
 
-from omegaconf import MissingMandatoryValue, OmegaConf
+from omegaconf import DictConfig, ListConfig, MissingMandatoryValue, OmegaConf
 from omegaconf._impl import select_value
 from omegaconf._utils import _ensure_container
-from omegaconf.errors import ConfigKeyError, InterpolationKeyError
+from omegaconf.errors import InterpolationKeyError
 
 
-@mark.parametrize("struct", [False, True, None])
+@mark.parametrize("struct", [False, True])
 class TestSelect:
-    @mark.parametrize(
-        "register_func",
-        [OmegaConf.legacy_register_resolver, OmegaConf.register_new_resolver],
-    )
     @mark.parametrize(
         "cfg, key, expected",
         [
+            # None returned
             param({}, "nope", None, id="dict:none"),
             param({}, "not.there", None, id="dict:none"),
             param({}, "still.not.there", None, id="dict:none"),
+            param({"a": 10}, "a.b", None, id="dict:nesting_into_value"),
+            param({"a": None}, "a.b", None, id="dict:nesting_into_none"),
+            param({"a": DictConfig(None)}, "a.b", None, id="dict:nesting_into_none"),
+            param({"a": ListConfig(None)}, "a.b", None, id="dict:nesting_into_none"),
+            # value returned
             param({"c": 1}, "c", 1, id="dict:int"),
             param({"a": {"v": 1}}, "a.v", 1, id="dict:int"),
             param({"a": {"v": 1}}, "a", {"v": 1}, id="dict:dict"),
@@ -41,13 +42,38 @@ class TestSelect:
             param({"a": {"v": 1}}, "", {"a": {"v": 1}}, id="select_root"),
             param({"a": {"b": 1}, "c": "one=${a.b}"}, "c", "one=1", id="inter"),
             param({"a": {"b": "one=${n}"}, "n": 1}, "a.b", "one=1", id="inter"),
-            param({"a": {"b": "one=${func:1}"}}, "a.b", "one=_1_", id="resolver"),
             # relative selection
             param({"a": {"b": {"c": 10}}}, ".a", {"b": {"c": 10}}, id="relative"),
             param({"a": {"b": {"c": 10}}}, ".a.b", {"c": 10}, id="relative"),
         ],
     )
     def test_select(
+        self,
+        restore_resolvers: Any,
+        cfg: Any,
+        key: Any,
+        expected: Any,
+        struct: Optional[bool],
+    ) -> None:
+        cfg = _ensure_container(cfg)
+        OmegaConf.set_struct(cfg, struct)
+        if isinstance(expected, RaisesContext):
+            with expected:
+                OmegaConf.select(cfg, key)
+        else:
+            assert OmegaConf.select(cfg, key) == expected
+
+    @mark.parametrize(
+        "register_func",
+        [OmegaConf.legacy_register_resolver, OmegaConf.register_new_resolver],
+    )
+    @mark.parametrize(
+        "cfg, key, expected",
+        [
+            param({"a": {"b": "one=${func:1}"}}, "a.b", "one=_1_", id="resolver"),
+        ],
+    )
+    def test_select_resolver(
         self,
         restore_resolvers: Any,
         cfg: Any,
@@ -107,31 +133,6 @@ def test_select_default_throw_on_missing(
         with raises(MissingMandatoryValue):
             OmegaConf.select(cfg, key, default=default, throw_on_missing=True)
 
-    @mark.parametrize(
-        ("cfg", "key", "exc"),
-        [
-            param(
-                {"int": 0},
-                "int.y",
-                raises(
-                    ConfigKeyError,
-                    match=re.escape(
-                        "Error trying to access int.y: node `int` is not a container "
-                        "and thus cannot contain `y`"
-                    ),
-                ),
-                id="non_container",
-            ),
-        ],
-    )
-    def test_select_error(
-        self, cfg: Any, key: Any, exc: Any, struct: Optional[bool]
-    ) -> None:
-        cfg = _ensure_container(cfg)
-        OmegaConf.set_struct(cfg, struct)
-        with exc:
-            OmegaConf.select(cfg, key)
-
     @mark.parametrize(
         ("cfg", "key"),
         [