Enum upper case

[sjunges]

Change all enums to upper case as recommend by the documentation.
Originally posted by @volkm in #403 (review)

We should probably do this while ensuring "deprecated" old enum names?

[volkm]

We can definitely still support the old enum names. The question is how we indicate the deprecation. One way seems to be to only have the new names in the pybind part, and add the old names on the Python side together with a warning.
This requires some additional code and we need to specify the mapping from old to new enum. The LLM code suggestion can be found below.

Alternatively, we still support the old enums alongside the new ones but do not provide any warning. This allows to keep everything in the pybind part and is much simpler. However, there is no indication to users that they should modify their code.

Code

The LLM suggestion for adding the warnings on the Python side:

lib/stormpy/_enum_compat.py — the core of the deprecation machinery:
import enum
import warnings
import sys
from deprecated.sphinx import deprecated


class _DeprecatingEnumMeta(enum.EnumMeta):
    """Metaclass that intercepts old member names and warns."""

    def __getattr__(cls, name):
        deprecated_map = cls.__dict__.get("_deprecated_map", {})
        if name in deprecated_map:
            new_name = deprecated_map[name]
            warnings.warn(
                f"'{cls.__name__}.{name}' is deprecated, "
                f"use '{cls.__name__}.{new_name}'",
                DeprecationWarning,
                stacklevel=2,
            )
            return getattr(cls, new_name)
        return super().__getattr__(name)


def _patch_enum(enum_cls, deprecated_map):
    """Create a metaclass-based subclass with deprecated name support."""
    return _DeprecatingEnumMeta(
        enum_cls.__name__,
        (enum_cls,),
        {"_deprecated_map": deprecated_map},
    )


ENUM_DEPRECATIONS = {
    # Dotted path in sys.modules -> {old_name: new_name}
    "stormpy._core.OptimizationDirection": {
        "Minimize": "MINIMIZE",
        "Maximize": "MAXIMIZE",
    },
    "stormpy._core.EquationSolverType": {
        "native": "NATIVE",
        "eigen": "EIGEN",
        "elimination": "ELIMINATION",
        "gmmxx": "GMMXX",
        "topological": "TOPOLOGICAL",
    },
    # ... continues for all ~17 renamed enums
}


def patch_all():
    """Patch all enum classes listed in ENUM_DEPRECATIONS.

    Must be called after all C++ extension modules are loaded.
    Replaces the enum class with a subclass in every module that references it.
    """
    changed = {}  # old class -> new subclass
    for dotted_path, mapping in ENUM_DEPRECATIONS.items():
        mod_name, _, attr_name = dotted_path.rpartition(".")
        mod = sys.modules.get(mod_name)
        if mod is None:
            continue
        enum_cls = getattr(mod, attr_name, None)
        if enum_cls is None:
            continue
        new_cls = _patch_enum(enum_cls, mapping)
        new_cls.__module__ = enum_cls.__module__
        changed[enum_cls] = new_cls
        setattr(mod, attr_name, new_cls)

    # Update all other modules that hold a reference to the old class
    for mod in list(sys.modules.values()):
        if mod is None:
            continue
        for attr_name in dir(mod):
            old = getattr(mod, attr_name, None)
            if old in changed:
                setattr(mod, attr_name, changed[old])

[sjunges]

If we are going to break the package structure anyways, then I am not sure whether this is worth it.

[volkm]

I would also favor not spending too much effort into a thing which will be obsolete anyway. Then I will just drop the support for the old enums.