Make .NET enums real Python IntEnum via make_native_enum; update FracturedJsonOptions to accept Python Enums; add tests

Author: masaccio

src/fractured_json/__init__.py

@@ -41,6 +41,7 @@ def load_runtime() -> None:
     Type,
 )
 from System.Reflection import BindingFlags  # pyright: ignore[reportMissingImports] # noqa: E402
+from enum import Enum as PyEnum, IntEnum  # Python enum types for interop helpers
 
 
 def get_object_types() -> dict[str, "System.RuntimeType"]:
@@ -63,53 +64,27 @@ def snake_enum_to_pascal(name: str) -> str:
 
 
 class NativeEnum:
-    """Generic base class that dynamically maps .NET enums to Pythonic attributes."""
+    """Compatibility shim: legacy class providing .name and .value for dynamically-created enums.
+
+    New code prefers real stdlib `Enum`/`IntEnum` types created with `make_native_enum`,
+    but this class is preserved for backwards compatibility.
+    """
 
     _native_type = None
 
-    def __init_subclass__(
-        cls,
-        native_type: object | None = None,
-        **kwargs: dict[str, bool | int | str],
-    ) -> None:
-        super().__init_subclass__(**kwargs)
-
-        # If class is dynamically constructed using type()
-        if hasattr(cls, "_native_type") and cls._native_type is not None:
-            native_type = cls._native_type
-
-        native_names = [
-            str(x)
-            for x in native_type.GetEnumNames()  # pyright: ignore[reportAttributeAccessIssue]
-        ]
-        native_values = [
-            int(x)
-            for x in native_type.GetEnumValues()  # pyright: ignore[reportAttributeAccessIssue]
-        ]
-
-        name_to_value = dict(zip(native_names, native_values, strict=True))
-
-        for native_name in native_names:
-            py_name = to_snake_case(native_name, upper=True)
-            native_value = name_to_value[native_name]
-            # Create instance and store on class
-            instance = cls(py_name, native_value)
-            setattr(cls, py_name, instance)
+    def __init__(self, py_name: str, native_value: int) -> None:
+        # Legacy instance shape (kept for compatibility with older code)
+        self._py_name = py_name
+        self._py_value = native_value
 
     @property
     def name(self) -> str:
-        """The string name of the enum value."""
         return self._py_name
 
     @property
     def value(self) -> int:
-        """The integer value of the enum."""
         return self._py_value
 
-    def __init__(self, py_name: str, native_value: int) -> None:
-        self._py_name = py_name
-        self._py_value = native_value
-
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}.{self._py_name}"
 
@@ -122,6 +97,55 @@ def __hash__(self) -> int:
         return hash(self._py_value)
 
 
+# Cache for created python enum classes keyed by dotnet type representation
+_native_enum_cache: dict[str, type] = {}
+
+
+def make_native_enum(dotnet_type, *, int_enum: bool = True):
+    """Create a Python `Enum`/`IntEnum` for a .NET enum type.
+
+    The returned class has attached helpers:
+    - `_native_type` (the original dotnet type)
+    - `to_dotnet(self)` -> returns a .NET Enum parsed instance when available, otherwise the Pascal-case name
+    - `from_dotnet(cls, dotnet_value)` -> returns the Python enum member from a .NET value
+    """
+    # Cache by dotnet type to ensure repeated lookups return the same Python class
+    key = str(dotnet_type)
+    if key in _native_enum_cache:
+        return _native_enum_cache[key]
+
+    # Delay import to avoid conflicts on module import ordering
+    from enum import IntEnum
+
+    native_names = [str(x) for x in dotnet_type.GetEnumNames()]
+    native_values = [int(x) for x in dotnet_type.GetEnumValues()]
+    members = {to_snake_case(n, upper=True): v for n, v in zip(native_names, native_values)}
+
+    base = IntEnum if int_enum else PyEnum
+    cls = base(dotnet_type.Name, members)
+    cls._native_type = dotnet_type
+
+    _native_enum_cache[key] = cls
+
+    # Instance -> dotnet conversion (best effort)
+    def to_dotnet(self):
+        try:
+            return Enum.Parse(self._native_type, snake_enum_to_pascal(self.name))
+        except Exception:
+            return snake_enum_to_pascal(self.name)
+
+    cls.to_dotnet = to_dotnet
+
+    @classmethod
+    def from_dotnet(cls, dotnet_value):
+        return cls(int(dotnet_value))
+
+    cls.from_dotnet = from_dotnet
+
+    return cls
+
+
+
 types = get_object_types()
 FormatterType = types["Formatter"]
 FracturedJsonOptionsType = types["FracturedJsonOptions"]
@@ -131,7 +155,7 @@ def __hash__(self) -> int:
     "FracturedJsonOptions",
 ]
 for enum_name in [x.Name for x in types.values() if x.IsEnum]:
-    enum_type = type(enum_name, (NativeEnum,), {"_native_type": types[enum_name]})
+    enum_type = make_native_enum(types[enum_name], int_enum=True)
     globals()[enum_name] = enum_type
     __all__.append(enum_type)  # noqa: PYI056
 
@@ -181,8 +205,8 @@ def get(self, name: str) -> int | bool | str | NativeEnum:
         prop = self._properties[name]["prop"]
         if self._properties[name]["is_enum"]:
             native_value = prop.GetValue(self._dotnet_instance)
-            derived_enum = type(prop.Name, (NativeEnum,), {"_native_type": prop.PropertyType})
-            return derived_enum(to_snake_case(str(native_value), upper=True), (int(native_value)))
+            derived_enum = make_native_enum(prop.PropertyType, int_enum=True)
+            return derived_enum(int(native_value))
 
         return prop.GetValue(self._dotnet_instance)
 
@@ -214,6 +238,9 @@ def _to_dotnet_type(
             return Boolean(value)
         if target_type.FullName == "System.String" and isinstance(value, str):
             return String(value)
+        # Accept both legacy `NativeEnum` shim instances and modern Python Enum instances
+        if target_type.IsEnum and isinstance(value, PyEnum):
+            return Enum.Parse(prop.PropertyType, snake_enum_to_pascal(value.name))
         if target_type.IsEnum and isinstance(value, NativeEnum):
             return Enum.Parse(prop.PropertyType, snake_enum_to_pascal(value.name))
         if target_type.IsEnum and isinstance(value, str):

tests/test_native_enum.py

@@ -0,0 +1,66 @@
+import inspect
+import enum
+
+import fractured_json
+
+
+def test_comment_policy_is_intenum_and_members():
+    # Ensure module exposes CommentPolicy converted from .NET enum
+    CommentPolicy = fractured_json.CommentPolicy
+    assert inspect.isclass(CommentPolicy)
+    # Should be a python Enum (IntEnum specifically)
+    assert issubclass(CommentPolicy, enum.IntEnum)
+
+    # Members should be present and convert to expected integer values
+    assert "TREAT_AS_ERROR" in CommentPolicy.__members__
+    assert CommentPolicy.TREAT_AS_ERROR.value == 0
+    assert CommentPolicy.REMOVE.value == 1
+    assert CommentPolicy.PRESERVE.value == 2
+
+    # Lookup by value should return the correct member
+    assert CommentPolicy(1) is CommentPolicy.REMOVE
+
+    # Iteration order is deterministic
+    members = list(CommentPolicy)
+    assert members[0] is CommentPolicy.TREAT_AS_ERROR
+    assert members[1] is CommentPolicy.REMOVE
+    assert members[2] is CommentPolicy.PRESERVE
+
+
+def test_options_roundtrip_accepts_pyenum():
+    # FracturedJsonOptions should accept a Python enum value for enum properties
+    opts = fractured_json.FracturedJsonOptions()
+
+    # Default is TreatAsError
+    assert opts.comment_policy is fractured_json.CommentPolicy.TREAT_AS_ERROR
+
+    # Set using Python enum
+    opts.comment_policy = fractured_json.CommentPolicy.PRESERVE
+    assert opts.comment_policy is fractured_json.CommentPolicy.PRESERVE
+
+    # Setting via name should still work
+    opts.set("comment_policy", "Remove")
+    assert opts.comment_policy is fractured_json.CommentPolicy.REMOVE
+
+
+def test_make_native_enum_helper_roundtrip():
+    # Build a fake dotnet enum type mimicking pythonnet's shape
+    class FakeDotNetEnum:
+        Name = "ExampleEnum"
+
+        @staticmethod
+        def GetEnumNames():
+            return ["AlphaBeta", "Gamma"]
+
+        @staticmethod
+        def GetEnumValues():
+            return [5, 42]
+
+    Example = fractured_json.make_native_enum(FakeDotNetEnum, int_enum=True)
+    assert issubclass(Example, enum.IntEnum)
+    assert Example.ALPHA_BETA.value == 5
+    assert Example.GAMMA.value == 42
+    # from_dotnet should accept numeric values
+    assert Example.from_dotnet(42) is Example.GAMMA
+    # to_dotnet returns the Pascal name when dotnet interop isn't available
+    assert Example.ALPHA_BETA.to_dotnet() == "AlphaBeta"