omegaconf-pydevd 2.4.0.dev10__tar.gz

omegaconf_pydevd-2.4.0.dev10/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2018, Omry Yadan
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

omegaconf_pydevd-2.4.0.dev10/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+include version.py
+recursive-include pydevd_plugins *.py

omegaconf_pydevd-2.4.0.dev10/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: omegaconf-pydevd
+Version: 2.4.0.dev10
+Summary: pydevd debugger plugin for OmegaConf
+Home-page: https://github.com/omry/omegaconf
+Author: Omry Yadan
+Author-email: omry@yadan.net
+Keywords: omegaconf pydevd debugpy debugger
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: omegaconf==2.4.0.dev10
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OmegaConf pydevd Plugin
+
+`omegaconf-pydevd` provides the optional `pydevd` plugin for OmegaConf objects.
+
+This debugger integration is packaged separately from the main `omegaconf`
+distribution so that the global `pydevd_plugins` namespace is only installed on
+systems that explicitly opt into it.
+
+## Installation
+
+```bash
+pip install omegaconf-pydevd
+```
+
+## Debugger Demo
+
+Use [examples/debug_demo.py](./examples/debug_demo.py) to inspect OmegaConf
+objects in the debugger with `omegaconf-pydevd` installed.
+
+Set a breakpoint on `print(cfg)` and inspect:
+
+- `cfg`
+- `cfg.greeting`
+- `cfg.subprojects`
+- `cfg.project`
+
+With `omegaconf-pydevd` installed:
+
+- missing fields render as debugger values instead of surfacing a debugger-time
+  exception while inspecting them
+- interpolations are shown more clearly, including their resolved values
+
+### Example Rendering
+
+![OmegaConf pydevd debugger rendering](/subprojects/omegaconf-pydevd/docs/with-plugin.png "OmegaConf pydevd debugger rendering")
+
+## Resolver Mode
+
+Use the `OC_PYDEVD_RESOLVER` environment variable to select which resolver to
+install:
+
+- `USER`: default behavior, useful when debugging OmegaConf objects
+- `DEV`: useful when debugging OmegaConf itself and inspecting its internal
+  data model
+- `DISABLE`: disable the OmegaConf resolver
+
+Example:
+
+```bash
+OC_PYDEVD_RESOLVER=DEV python your_program.py
+```
+
+## Development
+
+From this repository root:
+
+```bash
+cd subprojects/omegaconf-pydevd
+pip install -r ../../requirements/dev.txt -e .
+pytest
+```

omegaconf_pydevd-2.4.0.dev10/README.md

@@ -0,0 +1,61 @@
+# OmegaConf pydevd Plugin
+
+`omegaconf-pydevd` provides the optional `pydevd` plugin for OmegaConf objects.
+
+This debugger integration is packaged separately from the main `omegaconf`
+distribution so that the global `pydevd_plugins` namespace is only installed on
+systems that explicitly opt into it.
+
+## Installation
+
+```bash
+pip install omegaconf-pydevd
+```
+
+## Debugger Demo
+
+Use [examples/debug_demo.py](./examples/debug_demo.py) to inspect OmegaConf
+objects in the debugger with `omegaconf-pydevd` installed.
+
+Set a breakpoint on `print(cfg)` and inspect:
+
+- `cfg`
+- `cfg.greeting`
+- `cfg.subprojects`
+- `cfg.project`
+
+With `omegaconf-pydevd` installed:
+
+- missing fields render as debugger values instead of surfacing a debugger-time
+  exception while inspecting them
+- interpolations are shown more clearly, including their resolved values
+
+### Example Rendering
+
+![OmegaConf pydevd debugger rendering](/subprojects/omegaconf-pydevd/docs/with-plugin.png "OmegaConf pydevd debugger rendering")
+
+## Resolver Mode
+
+Use the `OC_PYDEVD_RESOLVER` environment variable to select which resolver to
+install:
+
+- `USER`: default behavior, useful when debugging OmegaConf objects
+- `DEV`: useful when debugging OmegaConf itself and inspecting its internal
+  data model
+- `DISABLE`: disable the OmegaConf resolver
+
+Example:
+
+```bash
+OC_PYDEVD_RESOLVER=DEV python your_program.py
+```
+
+## Development
+
+From this repository root:
+
+```bash
+cd subprojects/omegaconf-pydevd
+pip install -r ../../requirements/dev.txt -e .
+pytest
+```

omegaconf_pydevd-2.4.0.dev10/omegaconf_pydevd.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: omegaconf-pydevd
+Version: 2.4.0.dev10
+Summary: pydevd debugger plugin for OmegaConf
+Home-page: https://github.com/omry/omegaconf
+Author: Omry Yadan
+Author-email: omry@yadan.net
+Keywords: omegaconf pydevd debugpy debugger
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: omegaconf==2.4.0.dev10
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OmegaConf pydevd Plugin
+
+`omegaconf-pydevd` provides the optional `pydevd` plugin for OmegaConf objects.
+
+This debugger integration is packaged separately from the main `omegaconf`
+distribution so that the global `pydevd_plugins` namespace is only installed on
+systems that explicitly opt into it.
+
+## Installation
+
+```bash
+pip install omegaconf-pydevd
+```
+
+## Debugger Demo
+
+Use [examples/debug_demo.py](./examples/debug_demo.py) to inspect OmegaConf
+objects in the debugger with `omegaconf-pydevd` installed.
+
+Set a breakpoint on `print(cfg)` and inspect:
+
+- `cfg`
+- `cfg.greeting`
+- `cfg.subprojects`
+- `cfg.project`
+
+With `omegaconf-pydevd` installed:
+
+- missing fields render as debugger values instead of surfacing a debugger-time
+  exception while inspecting them
+- interpolations are shown more clearly, including their resolved values
+
+### Example Rendering
+
+![OmegaConf pydevd debugger rendering](/subprojects/omegaconf-pydevd/docs/with-plugin.png "OmegaConf pydevd debugger rendering")
+
+## Resolver Mode
+
+Use the `OC_PYDEVD_RESOLVER` environment variable to select which resolver to
+install:
+
+- `USER`: default behavior, useful when debugging OmegaConf objects
+- `DEV`: useful when debugging OmegaConf itself and inspecting its internal
+  data model
+- `DISABLE`: disable the OmegaConf resolver
+
+Example:
+
+```bash
+OC_PYDEVD_RESOLVER=DEV python your_program.py
+```
+
+## Development
+
+From this repository root:
+
+```bash
+cd subprojects/omegaconf-pydevd
+pip install -r ../../requirements/dev.txt -e .
+pytest
+```

omegaconf_pydevd-2.4.0.dev10/omegaconf_pydevd.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+version.py
+omegaconf_pydevd.egg-info/PKG-INFO
+omegaconf_pydevd.egg-info/SOURCES.txt
+omegaconf_pydevd.egg-info/dependency_links.txt
+omegaconf_pydevd.egg-info/namespace_packages.txt
+omegaconf_pydevd.egg-info/requires.txt
+omegaconf_pydevd.egg-info/top_level.txt
+pydevd_plugins/__init__.py
+pydevd_plugins/extensions/__init__.py
+pydevd_plugins/extensions/pydevd_plugin_omegaconf.py
+tests/test_pydev_resolver_plugin.py
+tests/test_pydevd_plugin_namespace.py

omegaconf_pydevd-2.4.0.dev10/omegaconf_pydevd.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

omegaconf_pydevd-2.4.0.dev10/omegaconf_pydevd.egg-info/namespace_packages.txt

@@ -0,0 +1,2 @@
+pydevd_plugins
+pydevd_plugins.extensions

omegaconf_pydevd-2.4.0.dev10/omegaconf_pydevd.egg-info/requires.txt

@@ -0,0 +1 @@
+omegaconf==2.4.0.dev10

omegaconf_pydevd-2.4.0.dev10/omegaconf_pydevd.egg-info/top_level.txt

@@ -0,0 +1 @@
+pydevd_plugins

omegaconf_pydevd-2.4.0.dev10/pydevd_plugins/__init__.py

@@ -0,0 +1,6 @@
+try:
+    __import__("pkg_resources").declare_namespace(__name__)
+except ImportError:
+    import pkgutil
+
+    __path__ = pkgutil.extend_path(__path__, __name__)

omegaconf_pydevd-2.4.0.dev10/pydevd_plugins/extensions/__init__.py

@@ -0,0 +1,6 @@
+try:
+    __import__("pkg_resources").declare_namespace(__name__)
+except ImportError:
+    import pkgutil
+
+    __path__ = pkgutil.extend_path(__path__, __name__)

omegaconf_pydevd-2.4.0.dev10/pydevd_plugins/extensions/pydevd_plugin_omegaconf.py

@@ -0,0 +1,126 @@
+# based on https://github.com/fabioz/PyDev.Debugger/tree/main/pydevd_plugins/extensions
+import os
+import sys
+from typing import Any, Dict
+
+from _pydevd_bundle.pydevd_extension_api import (  # type: ignore
+    StrPresentationProvider,
+    TypeResolveProvider,
+)
+
+DEBUG = False
+
+
+def print_debug(msg: str) -> None:  # pragma: no cover
+    if DEBUG:
+        print(msg)
+
+
+def find_mod_attr(mod_name: str, attr: str) -> Any:
+    mod = sys.modules.get(mod_name)
+    return getattr(mod, attr, None)
+
+
+class OmegaConfDeveloperResolver(object):
+    def can_provide(self, type_object: Any, type_name: str) -> bool:
+        Node = find_mod_attr("omegaconf", "Node")
+        return Node is not None and issubclass(type_object, Node)
+
+    def resolve(self, obj: Any, attribute: str) -> Any:
+        return getattr(obj, attribute)
+
+    def get_dictionary(self, obj: Any) -> Any:
+        return obj.__dict__
+
+
+class OmegaConfUserResolver(StrPresentationProvider):  # type: ignore
+    def __init__(self) -> None:
+        self.Node = find_mod_attr("omegaconf", "Node")
+        self.ValueNode = find_mod_attr("omegaconf", "ValueNode")
+        self.ListConfig = find_mod_attr("omegaconf", "ListConfig")
+        self.DictConfig = find_mod_attr("omegaconf", "DictConfig")
+        self.InterpolationResolutionError = find_mod_attr(
+            "omegaconf.errors", "InterpolationResolutionError"
+        )
+
+    def can_provide(self, type_object: Any, type_name: str) -> bool:
+        return self.Node is not None and issubclass(type_object, self.Node)
+
+    def resolve(self, obj: Any, attribute: Any) -> Any:
+        if isinstance(obj, self.ListConfig) and isinstance(attribute, str):
+            attribute = int(attribute)
+
+        if isinstance(obj, self.Node):
+            obj = obj._dereference_node()
+
+        val = obj.__dict__["_content"][attribute]
+
+        print_debug(
+            f"resolving {obj} ({type(obj).__name__}), {attribute} -> {val} ({type(val).__name__})"
+        )
+
+        return val
+
+    def _is_simple_value(self, val: Any) -> bool:
+        return (
+            isinstance(val, self.ValueNode)
+            and not val._is_none()
+            and not val._is_missing()
+            and not val._is_interpolation()
+        )
+
+    def get_dictionary(self, obj: Any) -> Dict[str, Any]:
+        d = self._get_dictionary(obj)
+        print_debug(f"get_dictionary {obj}, ({type(obj).__name__}) -> {d}")
+        return d
+
+    def _get_dictionary(self, obj: Any) -> Dict[str, Any]:
+        if isinstance(obj, self.Node):
+            obj = obj._maybe_dereference_node()
+            if obj is None or obj._is_none() or obj._is_missing():
+                return {}
+
+        if isinstance(obj, self.DictConfig):
+            d = {}
+            for k, v in obj.__dict__["_content"].items():
+                if self._is_simple_value(v):
+                    v = v._value()
+                d[k] = v
+        elif isinstance(obj, self.ListConfig):
+            d = {}
+            for idx, v in enumerate(obj.__dict__["_content"]):
+                if self._is_simple_value(v):
+                    v = v._value()
+                d[str(idx)] = v
+        else:
+            d = {}
+
+        return d
+
+    def get_str(self, val: Any) -> str:
+        if val._is_missing():
+            return "??? <MISSING>"
+        if val._is_interpolation():
+            try:
+                dr = val._dereference_node()
+            except self.InterpolationResolutionError as e:
+                dr = f"ERR: {e}"
+            return f"{val._value()} -> {dr}"
+        else:
+            return f"{val}"
+
+
+# OC_PYDEVD_RESOLVER env can take:
+#  DISABLE: Do not install a pydevd resolver
+#  USER: Install a resolver for OmegaConf users (default)
+#  DEV: Install a resolver for OmegaConf developers. Shows underlying data-model in the debugger.
+resolver = os.environ.get("OC_PYDEVD_RESOLVER", "USER").upper()
+if resolver != "DISABLE":  # pragma: no cover
+    if resolver == "USER":
+        TypeResolveProvider.register(OmegaConfUserResolver)
+    elif resolver == "DEV":
+        TypeResolveProvider.register(OmegaConfDeveloperResolver)
+    else:
+        sys.stderr.write(
+            f"OmegaConf pydev plugin: Not installing. Unknown mode {resolver}. Supported one of [USER, DEV, DISABLE]\n"
+        )

omegaconf_pydevd-2.4.0.dev10/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

omegaconf_pydevd-2.4.0.dev10/setup.py

@@ -0,0 +1,53 @@
+# type: ignore
+import pathlib
+import re
+
+import setuptools
+
+ROOT = pathlib.Path(__file__).parent.resolve()
+
+
+def find_version(*file_paths: str) -> str:
+    with open(ROOT / pathlib.Path(*file_paths), "r", encoding="utf-8") as fp:
+        version_file = fp.read()
+    version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M)
+    if version_match:
+        return version_match.group(1)
+    raise RuntimeError("Unable to find version string.")
+
+
+VERSION = find_version("version.py")
+
+with (ROOT / "README.md").open("r", encoding="utf-8") as fh:
+    LONG_DESC = fh.read()
+
+setuptools.setup(
+    name="omegaconf-pydevd",
+    version=VERSION,
+    author="Omry Yadan",
+    author_email="omry@yadan.net",
+    description="pydevd debugger plugin for OmegaConf",
+    long_description=LONG_DESC,
+    long_description_content_type="text/markdown",
+    url="https://github.com/omry/omegaconf",
+    keywords="omegaconf pydevd debugpy debugger",
+    packages=[
+        "pydevd_plugins",
+        "pydevd_plugins.extensions",
+    ],
+    namespace_packages=[
+        "pydevd_plugins",
+        "pydevd_plugins.extensions",
+    ],
+    python_requires=">=3.10",
+    classifiers=[
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
+        "License :: OSI Approved :: BSD License",
+        "Operating System :: OS Independent",
+    ],
+    install_requires=[f"omegaconf=={VERSION}"],
+)

omegaconf_pydevd-2.4.0.dev10/tests/test_pydev_resolver_plugin.py

@@ -0,0 +1,268 @@
+import builtins
+from enum import Enum
+from typing import Any
+
+from pydevd_plugins.extensions.pydevd_plugin_omegaconf import (
+    OmegaConfDeveloperResolver,
+    OmegaConfUserResolver,
+)
+from pytest import fixture, mark, param
+
+from omegaconf import (
+    AnyNode,
+    BooleanNode,
+    BytesNode,
+    Container,
+    DictConfig,
+    EnumNode,
+    FloatNode,
+    IntegerNode,
+    ListConfig,
+    Node,
+    OmegaConf,
+    PathNode,
+    StringNode,
+    ValueNode,
+)
+from omegaconf._utils import type_str
+
+
+class Color(Enum):
+    RED = 1
+
+
+@fixture
+def resolver() -> Any:
+    yield OmegaConfUserResolver()
+
+
+@mark.parametrize(
+    ("obj", "expected"),
+    [
+        param(AnyNode(10), {}, id="any:10"),
+        param(StringNode("foo"), {}, id="str:foo"),
+        param(IntegerNode(10), {}, id="int:10"),
+        param(FloatNode(3.14), {}, id="float:3.14"),
+        param(BooleanNode(True), {}, id="bool:True"),
+        param(BytesNode(b"binary"), {}, id="bytes:binary"),
+        param(PathNode("hello.txt"), {}, id="path:hello.txt"),
+        param(EnumNode(enum_type=Color, value=Color.RED), {}, id="Color:Color.RED"),
+        param(AnyNode("${foo}", parent=DictConfig({"foo": 10})), {}, id="any:inter_10"),
+        param(DictConfig({"a": 10}), {"a": AnyNode(10)}, id="dict"),
+        param(
+            DictConfig({"a": 10, "b": "${a}"}),
+            {"a": AnyNode(10), "b": AnyNode("${a}")},
+            id="dict:interpolation_value",
+        ),
+        param(
+            DictConfig({"a": 10, "b": "${zzz}"}),
+            {"a": AnyNode(10), "b": AnyNode("${zzz}")},
+            id="dict:interpolation_value_error",
+        ),
+        param(
+            DictConfig({"a": 10, "b": "foo_${a}"}),
+            {"a": AnyNode(10), "b": AnyNode("foo_${a}")},
+            id="dict:str_interpolation_value",
+        ),
+        param(DictConfig("${zzz}"), {}, id="dict:inter_error"),
+        param(
+            ListConfig(["a", "b"]), {"0": AnyNode("a"), "1": AnyNode("b")}, id="list"
+        ),
+        param(
+            ListConfig(["${1}", 10]),
+            {"0": AnyNode("${1}"), "1": AnyNode(10)},
+            id="list:interpolation_value",
+        ),
+        param(ListConfig("${zzz}"), {}, id="list:inter_error"),
+    ],
+)
+def test_get_dictionary_node(resolver: Any, obj: Any, expected: Any) -> None:
+    res = resolver.get_dictionary(obj)
+    assert res == expected
+
+
+@mark.parametrize(
+    ("obj", "attribute", "expected"),
+    [
+        param(DictConfig({"a": 10}), "a", AnyNode(10), id="dict"),
+        param(
+            DictConfig({"a": DictConfig(None)}),
+            "a",
+            DictConfig(None),
+            id="dict:none",
+        ),
+        param(ListConfig([10]), 0, AnyNode(10), id="list"),
+        param(ListConfig(["???"]), 0, AnyNode("???"), id="list:missing_item"),
+    ],
+)
+def test_resolve(
+    resolver: Any,
+    obj: Any,
+    attribute: str,
+    expected: Any,
+) -> None:
+    res = resolver.resolve(obj, attribute)
+    assert res == expected
+    assert type(res) is type(expected)
+
+
+@mark.parametrize(
+    ("obj", "attribute", "expected"),
+    [
+        param(
+            OmegaConf.create({"a": 10, "inter": "${a}"}), "inter", {}, id="dict:inter"
+        ),
+        param(
+            OmegaConf.create({"missing": "???"}),
+            "missing",
+            {},
+            id="dict:missing_value",
+        ),
+        param(OmegaConf.create({"none": None}), "none", {}, id="dict:none_value"),
+        param(
+            OmegaConf.create({"none": DictConfig(None)}),
+            "none",
+            {},
+            id="dict:none_dictconfig_value",
+        ),
+        param(
+            OmegaConf.create({"missing": DictConfig("???")}),
+            "missing",
+            {},
+            id="dict:missing_dictconfig_value",
+        ),
+        param(
+            OmegaConf.create({"a": {"b": 10}, "b": DictConfig("${a}")}),
+            "b",
+            {"b": 10},
+            id="dict:interpolation_dictconfig_value",
+        ),
+    ],
+)
+def test_get_dictionary_dictconfig(
+    resolver: Any,
+    obj: Any,
+    attribute: str,
+    expected: Any,
+) -> None:
+    field = resolver.resolve(obj, attribute)
+    res = resolver.get_dictionary(field)
+    assert res == expected
+    assert type(res) is type(expected)
+
+
+@mark.parametrize(
+    ("obj", "attribute", "expected"),
+    [
+        param(
+            ListConfig("${list}", parent=DictConfig({"list": [{"a": 10}]})),
+            "0",
+            {"a": 10},
+            id="inter_list:dict_element",
+        ),
+        param(
+            DictConfig("${dict}", parent=DictConfig({"dict": {"a": {"b": 10}}})),
+            "a",
+            {"b": 10},
+            id="inter_dict:dict_element",
+        ),
+    ],
+)
+def test_resolve_through_container_interpolation(
+    resolver: Any, obj: Any, attribute: str, expected: Any
+) -> None:
+    res = resolver.resolve(obj, attribute)
+    assert res == expected
+
+
+@mark.parametrize(
+    ("obj", "attribute", "expected"),
+    [
+        param(OmegaConf.create(["${.1}", 10]), "0", {}, id="list:inter_value"),
+        param(
+            OmegaConf.create({"a": ListConfig(None)}),
+            "a",
+            {},
+            id="list:none_listconfig_value",
+        ),
+        param(
+            OmegaConf.create({"a": ListConfig("???")}),
+            "a",
+            {},
+            id="list:missing_listconfig_value",
+        ),
+        param(
+            OmegaConf.create({"a": [1, 2], "b": ListConfig("${a}")}),
+            "b",
+            {"0": 1, "1": 2},
+            id="list:interpolation_listconfig_value",
+        ),
+    ],
+)
+def test_get_dictionary_listconfig(
+    resolver: Any,
+    obj: Any,
+    attribute: str,
+    expected: Any,
+) -> None:
+    field = resolver.resolve(obj, attribute)
+    res = resolver.get_dictionary(field)
+    assert res == expected
+    assert type(res) is type(expected)
+
+
+@mark.parametrize("resolver", [OmegaConfUserResolver(), OmegaConfDeveloperResolver()])
+@mark.parametrize(
+    ("type_", "expected"),
+    [
+        (Container, True),
+        (DictConfig, True),
+        (ListConfig, True),
+        (Node, True),
+        (ValueNode, True),
+        (AnyNode, True),
+        (IntegerNode, True),
+        (FloatNode, True),
+        (StringNode, True),
+        (BooleanNode, True),
+        (BytesNode, True),
+        (PathNode, True),
+        (EnumNode, True),
+        (builtins.int, False),
+        (dict, False),
+        (list, False),
+    ],
+)
+def test_can_provide(resolver: Any, type_: Any, expected: bool) -> None:
+    assert resolver.can_provide(type_, type_str(type_)) == expected
+
+
+@mark.parametrize(
+    ("obj", "expected"),
+    [
+        (AnyNode(10), "10"),
+        (AnyNode("???"), "??? <MISSING>"),
+        (
+            AnyNode("${foo}", parent=OmegaConf.create({})),
+            "${foo} -> ERR: Interpolation key 'foo' not found",
+        ),
+        (AnyNode("${foo}", parent=OmegaConf.create({"foo": 10})), "${foo} -> 10"),
+        (
+            DictConfig("${foo}", parent=OmegaConf.create({"foo": {"a": 10}})),
+            "${foo} -> {'a': 10}",
+        ),
+        (
+            ListConfig("${foo}", parent=OmegaConf.create({"foo": [1, 2]})),
+            "${foo} -> [1, 2]",
+        ),
+    ],
+)
+def test_get_str(resolver: Any, obj: Any, expected: str) -> None:
+    assert resolver.get_str(obj) == expected
+
+
+def test_dev_resolver() -> None:
+    resolver = OmegaConfDeveloperResolver()
+    cfg = OmegaConf.create({"foo": 10})
+    assert resolver.resolve(cfg, "_metadata") is cfg.__dict__["_metadata"]
+    assert resolver.get_dictionary(cfg) is cfg.__dict__

omegaconf_pydevd-2.4.0.dev10/tests/test_pydevd_plugin_namespace.py

@@ -0,0 +1,240 @@
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+OLD_NAMESPACE_INIT = """import pkgutil
+
+__path__ = pkgutil.extend_path(__path__, __name__)
+"""
+
+
+FAKE_PKG_RESOURCES = """_namespaces = set()
+
+
+def _package_paths(name):
+    import os
+    import sys
+
+    relpath = os.path.join(*name.split("."))
+    paths = []
+    for entry in sys.path:
+        if not entry:
+            continue
+        candidate = os.path.join(entry, relpath)
+        if os.path.isdir(candidate):
+            paths.append(candidate)
+    return paths
+
+
+def declare_namespace(name):
+    import sys
+
+    _namespaces.add(name)
+    sys.modules[name].__path__ = _package_paths(name)
+
+
+def fixup_namespace_packages(_):
+    import sys
+
+    for name in _namespaces:
+        module = sys.modules.get(name)
+        if module is not None:
+            module.__path__ = _package_paths(name)
+"""
+
+
+DISCOVERY_SCRIPT = """import importlib
+import json
+import os
+import pkgutil
+import sys
+
+import pydevd_plugins.extensions as extensions
+import pkg_resources
+
+plugin_root = os.environ["OMEGACONF_PYDEVD_PLUGIN_ROOT"]
+sys.path.insert(0, plugin_root)
+importlib.invalidate_caches()
+pkg_resources.fixup_namespace_packages(plugin_root)
+
+print(
+    json.dumps(
+        sorted(
+            name
+            for _, name, _ in pkgutil.walk_packages(
+                extensions.__path__, extensions.__name__ + "."
+            )
+        )
+    )
+)
+"""
+
+
+EDITABLE_DISCOVERY_SCRIPT = """import importlib
+import json
+import os
+import pkgutil
+import sys
+from importlib.machinery import ModuleSpec, PathFinder
+from importlib.util import spec_from_file_location
+from pathlib import Path
+
+import pkg_resources
+
+
+class EditableFinder:
+    @classmethod
+    def find_spec(cls, fullname, path=None, target=None):
+        plugin_root = Path(os.environ["OMEGACONF_PYDEVD_PLUGIN_ROOT"])
+        mapping = {
+            "pydevd_plugins": plugin_root / "pydevd_plugins",
+            "pydevd_plugins.extensions": plugin_root / "pydevd_plugins" / "extensions",
+        }
+        candidate = mapping.get(fullname)
+        if candidate is not None:
+            return spec_from_file_location(fullname, candidate / "__init__.py")
+
+        parent, _, _ = fullname.rpartition(".")
+        if parent in mapping:
+            return PathFinder.find_spec(fullname, path=[str(mapping[parent])])
+        return None
+
+
+def install_namespace_path(fullname, path_entry):
+    module = sys.modules.get(fullname)
+    if module is None:
+        module = importlib.import_module(fullname)
+    module_path = module.__dict__.setdefault("__path__", [])
+    if path_entry not in module_path:
+        module_path.append(path_entry)
+
+
+sys.meta_path.append(EditableFinder)
+
+if os.environ.get("OMEGACONF_PYDEVD_INSTALL_NAMESPACE_PATHS") == "1":
+    plugin_root = Path(os.environ["OMEGACONF_PYDEVD_PLUGIN_ROOT"])
+    install_namespace_path("pydevd_plugins", str(plugin_root / "pydevd_plugins"))
+    install_namespace_path(
+        "pydevd_plugins.extensions",
+        str(plugin_root / "pydevd_plugins" / "extensions"),
+    )
+
+import pydevd_plugins.extensions as extensions
+pkg_resources.fixup_namespace_packages(os.environ["OMEGACONF_PYDEVD_PLUGIN_ROOT"])
+
+print(
+    json.dumps(
+        sorted(
+            name
+            for _, name, _ in pkgutil.walk_packages(
+                extensions.__path__, extensions.__name__ + "."
+            )
+        )
+    )
+)
+"""
+
+
+def _write_namespace_package(root: Path, init_text: str) -> None:
+    extensions_dir = root / "pydevd_plugins" / "extensions"
+    extensions_dir.mkdir(parents=True)
+    (root / "pydevd_plugins" / "__init__.py").write_text(init_text)
+    (extensions_dir / "__init__.py").write_text(init_text)
+
+
+def _build_project(tmp_path: Path, init_text: str) -> tuple[Path, Path, Path]:
+    project_root = tmp_path / "project"
+    support_root = project_root / "support"
+    bundled_root = project_root / "bundled"
+    plugin_root = project_root / "plugin"
+
+    support_root.mkdir(parents=True)
+    (support_root / "pkg_resources.py").write_text(FAKE_PKG_RESOURCES)
+
+    _write_namespace_package(bundled_root, init_text)
+    _write_namespace_package(plugin_root, init_text)
+    (
+        bundled_root / "pydevd_plugins" / "extensions" / "pydevd_plugin_builtin.py"
+    ).write_text("X = 1\n")
+    (
+        plugin_root / "pydevd_plugins" / "extensions" / "pydevd_plugin_omegaconf.py"
+    ).write_text("Y = 1\n")
+
+    return project_root, support_root, bundled_root
+
+
+def _discover_extensions_from_editable_install(
+    tmp_path: Path,
+    *,
+    install_namespace_paths: bool,
+) -> list[str]:
+    project_root, support_root, bundled_root = _build_project(tmp_path, OLD_NAMESPACE_INIT)
+    plugin_root = project_root / "plugin"
+    env = os.environ.copy()
+    env["PYTHONPATH"] = os.pathsep.join([str(support_root), str(bundled_root)])
+    env["OMEGACONF_PYDEVD_PLUGIN_ROOT"] = str(plugin_root)
+    if install_namespace_paths:
+        env["OMEGACONF_PYDEVD_INSTALL_NAMESPACE_PATHS"] = "1"
+    result = subprocess.run(
+        [sys.executable, "-S", "-c", EDITABLE_DISCOVERY_SCRIPT],
+        check=True,
+        capture_output=True,
+        cwd=project_root,
+        env=env,
+        text=True,
+    )
+    return json.loads(result.stdout)
+
+
+def _discover_extensions(tmp_path: Path, init_text: str) -> list[str]:
+    project_root, support_root, bundled_root = _build_project(tmp_path, init_text)
+    plugin_root = project_root / "plugin"
+    env = os.environ.copy()
+    env["PYTHONPATH"] = os.pathsep.join([str(support_root), str(bundled_root)])
+    env["OMEGACONF_PYDEVD_PLUGIN_ROOT"] = str(plugin_root)
+    result = subprocess.run(
+        [sys.executable, "-S", "-c", DISCOVERY_SCRIPT],
+        check=True,
+        capture_output=True,
+        cwd=project_root,
+        env=env,
+        text=True,
+    )
+    return json.loads(result.stdout)
+
+
+def test_current_namespace_init_supports_late_plugin_discovery(tmp_path: Path) -> None:
+    init_text = (
+        Path(__file__).resolve().parents[1] / "pydevd_plugins" / "__init__.py"
+    ).read_text()
+    discovered = _discover_extensions(tmp_path, init_text)
+    assert "pydevd_plugins.extensions.pydevd_plugin_omegaconf" in discovered
+
+
+def test_old_namespace_init_does_not_support_late_plugin_discovery(
+    tmp_path: Path,
+) -> None:
+    discovered = _discover_extensions(tmp_path, OLD_NAMESPACE_INIT)
+    assert "pydevd_plugins.extensions.pydevd_plugin_omegaconf" not in discovered
+
+
+def test_editable_install_without_namespace_paths_is_not_discovered(
+    tmp_path: Path,
+) -> None:
+    discovered = _discover_extensions_from_editable_install(
+        tmp_path,
+        install_namespace_paths=False,
+    )
+    assert "pydevd_plugins.extensions.pydevd_plugin_omegaconf" not in discovered
+
+
+def test_editable_install_with_namespace_paths_is_discovered(
+    tmp_path: Path,
+) -> None:
+    discovered = _discover_extensions_from_editable_install(
+        tmp_path,
+        install_namespace_paths=True,
+    )
+    assert "pydevd_plugins.extensions.pydevd_plugin_omegaconf" in discovered

omegaconf_pydevd-2.4.0.dev10/version.py

@@ -0,0 +1 @@
+__version__ = "2.4.0.dev10"