Add support for dataclasses._MISSING_TYPE

[majiayu000]

Describe the bug

In Python version >= 3.11, dataclasses prohibits setting the default value to mutable objects

so this is often the case : common: Example = field(default_factory=Example)

Here, if no assignment is given, the object becomes a _MISSING_TYPE.

When using this type in OmegaConf.structured, an error will occur.

Just like this facebookresearch/fairseq#5359 (comment)

To Reproduce

Run the code below will get this error

from dataclasses import dataclass, field
from typing import List, Any
from omegaconf import OmegaConf


@dataclass
class Example:
    num: int


@dataclass
class TestConfig(Example):
    common: Example = field(default_factory=Example)


for k, field_info in TestConfig.__dataclass_fields__.items():
    default_value = field_info.default
    default_factory = field_info.default_factory
    print(
        f"Field: {k}, Default Value: {default_value}, Default Factory: {default_factory}"
    )

    mis = OmegaConf.structured(default_factory)

Expected behavior

Maybe add a type judgement for better compatibility.

Additional context

• OmegaConf version: 2.4.0.dev1/2.3.0/2.2.0
• Python version: 3.11
• Operating system: windows

[gregbugaj]

One option would be have a custom wheel that could contain the patch, another one would be to patch it at runtime.

Current Resolution:

pip install omegaconf==2.3.0
python3 /tmp/patches/patch-omegaconf-py312.py --no-confirm

Patch Injection (patches/patch-omegaconf-py312.py):

from dataclasses import _MISSING_TYPE
if isinstance(obj, _MISSING_TYPE):
    return OmegaConf.create({}, parent=parent, flags=flags)

import argparse
import os
import sys


def apply_patch(no_confirm):
    # Determine the path to the omegaconf.py file
    try:
        import omegaconf

        target_file = os.path.join(os.path.dirname(omegaconf.__file__), "omegaconf.py")
    except ImportError:
        print("Error: omegaconf module is not installed.")
        sys.exit(1)

    # Check if the file exists
    if not os.path.isfile(target_file):
        print(f"Error: {target_file} does not exist.")
        sys.exit(1)

    # Check if the patch is already present
    with open(target_file, "r") as file:
        content = file.read()
        if (
            "from dataclasses import _MISSING_TYPE" in content
            and "if isinstance(obj, _MISSING_TYPE):" in content
        ):
            print("Patch is already present in the file.")
            sys.exit(0)

    # Prompt the user to verify if they want to apply the patch
    if not no_confirm:
        response = (
            input(f"Do you want to apply the patch to {target_file}? (yes/no): ")
            .strip()
            .lower()
        )
        if response not in ["yes", "y"]:
            print("Patch not applied.")
            sys.exit(0)

    # Define the patch content
    patch_content = """
            from dataclasses import _MISSING_TYPE
            if isinstance(obj, _MISSING_TYPE):
                return OmegaConf.create({}, parent=parent, flags=flags)
    """

    # Apply the patch
    lines = content.split("\n")
    for i, line in enumerate(lines):
        if "if obj is _DEFAULT_MARKER_:" in line:
            lines.insert(i + 2, patch_content)
            break

    # Write the patched content back to the file
    with open(target_file, "w") as file:
        file.write("\n".join(lines))

    print(f"Patch applied successfully to {target_file}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Apply patch to omegaconf.py")
    parser.add_argument(
        "--no-confirm",
        action="store_true",
        help="Apply patch without confirmation",
        default=False,
    )
    args = parser.parse_args()

    apply_patch(args.no_confirm)

[omry]

Thanks for the report. I think the issue is in the repro rather than in OmegaConf’s dataclass handling.

OmegaConf handles the dataclass itself correctly:

OmegaConf.structured(Example)
# {'num': '???'}

The failure happens because the repro passes field_info.default_factory directly to OmegaConf.structured(). For fields without a default factory, dataclasses stores dataclasses.MISSING there, so this becomes:

OmegaConf.structured(dataclasses.MISSING)

dataclasses.MISSING is metadata meaning “no default factory was provided”; it is not itself a structured config, and definitely not a valid input to OmegaConf.

Why do you need to iterate over the dataclass fields and call OmegaConf.structured() on each default_factory directly?

I am closing it because it does not seem like a valid bug. feel free to continue discussion here about it.