Convert most enum definitions from the functional style to the class style

[IRDonch]

Summary

The class style has advantages in terms of IDE support. In particular, with Visual Studio Code, when the functional style is used:

• The enumeration type is considered to be a variable rather than a class.
• Autocomplete doesn't work for enum members.
• "Go to definition" doesn't work for enum members (and indeed, with the functional style they don't really have proper definitions).

Using the class style solves these problems. I would also argue that the class style is slightly more readable due to not as much punctuation (although I can't deny that the repetition of = auto() is quite ugly).

The class style removes the need to repeat the enum name twice (in fact, there were a few cases in the codebase in which the two names didn't match).

I converted most of the enums automatically by using the following script:

#!/usr/bin/env python3

import regex
import sys

from pathlib import Path

RE_ENUM = regex.compile(
   r'''
   ^(?<Indent>[ \t]*) (?<EnumName>\w+) \s* = \s* Enum \s* \( \s* (?: '.+?' | ".+?") \s* ,
       \s* \[ \s* (?: '(?<MemberName>.+?)' | "(?<MemberName>.+?)" )
       ( \s* , \s* (?: '(?<MemberName>.+?)' | "(?<MemberName>.+?)" ) )* (?: \s* , )?
       \s* \] \s* \) [ \t]*\n
   ''',
   regex.VERBOSE | regex.MULTILINE)

def main():
    for path in sys.argv[1:]:
        path = Path(path)

        contents = path.read_text()

        def replace(match):
            indent = match.group('Indent')
            enum_name = match.group('EnumName')
            member_names = match.captures('MemberName')
            replacement = f'{indent}class {enum_name}(Enum):\n' \
                + ''.join(f'{indent}    {name} = auto()\n' for name in member_names)
            print(f'{match.group()!r} -> {replacement!r}')
            return replacement

        contents = RE_ENUM.sub(replace, contents)

        path.write_text(contents)

main()

The rest of them I converted manually.

The only enum that I kept in the functional style is MotLabel, which has members that are not valid Python identifiers (and probably shouldn't be an enum at all).

How to test

N/A (although I should note that I used flake8 --select=F821 to make sure all modules import auto if needed).

Checklist

• I submit my changes into the develop branch
• [ ] I have added description of my changes into CHANGELOG N/A - no user-visible changes
• [ ] I have updated the documentation accordingly
• [ ] I have added tests to cover my changes
• [ ] I have linked related issues

License

• I submit my code changes under the same MIT License that covers the project.
  Feel free to contact the maintainers if that's a concern.
• I have updated the license header for each file (see an example below)

# Copyright (C) 2021 Intel Corporation
#
# SPDX-License-Identifier: MIT

[zhiltsov-max]

Probably, the need to assign values everywhere is the thing I dislike the most about class-style definitions. Also, I feel names next_idx() / auto_idx() for auto() would be more descriptive.

[IRDonch]

I agree, it's a nuisance. I think the advantages still outweigh it, though.

[zhiltsov-max]

The enumeration type is considered to be a variable rather than a class.

Having C++ background, I, personally, consider enums classes.

[IRDonch]

The enumeration type is considered to be a variable rather than a class.

Having C++ background, I, personally, consider enums classes.

That's great, because when you use class style they are considered classes. :-)