Support for Enumerations

[Atreyagaurav]

Would it be possible to add support for the Enum? Since it can be super useful in communicating states, I'd like to be able to define a schema like:
status = TaskStatus
where TaskStatus is an Enum defined as:

class TaskStatus(Enum):
    UNASSIGNED = 0
    ONGOING = 1
    COMPLETED = 2
    ON_HOLD = 3
    QUEUED = 4
    CANCELLED = -1

[Atreyagaurav]

If it isn't a good idea to add this support, how can I find a workaround? can I define my own init function after the JSON has been parsed so I can keep the schema as str then parse that string into TaskStatus Enum type.

EDIT: I found the workaround for reading by defining init like this:

    def __init__(self,json=None):
        super(Task,self).__init__(json)
        if json:
            self.status = TaskStatus[self.status]

And write by this:

    def write(self):
        json = super(Task,self).write()
        json['status']= json['status'].name
        return json

[pablomartinezm]

Overriding the "write" function is definitely one option, but I agree that it should be native support for enums check. In my opinion, the definition of an enum should be using the native set

schema = { "my_enum": {"FIRST_OPTION", "SECOND_OPTION", "THIRD_OPTION"}}

What do you think?

[Atreyagaurav]

You could extract the names from the Enum itself. Even though using native set would help you reduce the dependency on enum package, most people would be more likely to use an Enum to work with other modules in that function, so Enum class would be better, at least for me.

If I have to define the schema using a set, then I'd have no way to use that same definition in other functions outside of the class, But if I can use Enum, then I can define it once, and the schema and the other functions can use that as well.
Even more, even if we were to only use it inside the class we'd have to do string comparison every time to know which value of enum it holds? This might cause difficulties in editing the code later, and if we changed the Labels of Enum, an editor is unlikely to find the mistakes in the string comparison version instead of dot notation.

i.e.
var == 'FIRST_CHOICE' Vs var == MyEnum.FIRST_CHOICE, if I were to change the name to FIRST_CORRECT_CHOICE, syntax check would show the error in only the second case.

So I favor Enum class from enum package for the following reasons:

• Reusability
• Efficiency in comparison
• Low chance of error going undetected.. I guess.