Support Enum for Select-field

[floqqi]

I have got some use cases where I use a Enum in my models.

Example:

# definitions.py
from enum import Enum

class Gender(Enum):
    male = 'm'
    female = 'f'

# models.py
from definitions import Gender

class Person:
    def __init__(self, gender: Gender):
        self.gender = gender

Now it would be great if I could use the Enum in marshmallow.fields.Select:

# schemas.py
from marshmallow import fields, Schema
from definitions import Gender
from models import Person

class PersonSchema(Schema):
    gender = fields.Select(Gender)

    @staticmethod
    def make_object(data) -> Person:
        return Person(**data)

For backwards-compatibility enum34 could be used.

[floqqi]

If you think this might be a good idea I could provide a pull request if I find some time over the weekend.

[floqqi]

Ah, I see it's deprecated. Shouldn't then marshmallow.validate.OneOf support Enum?

[sloria]

@floqqi I would accept a PR adding Enum support to OneOf.

I'd rather not add enum34 as a dependency. We can just support Enum if it is available in the user's Python environment:

HAS_ENUM = False  # Check this in OneOf
try:
    import enum
except ImportError:
    pass
else:
    HAS_ENUM = True

[sloria]

Another option is to add a separate Enum validator. That way, we can avoid type-checking in OneOf.

[ctolsen]

I've been using an Enum field like this:

class Enum(fields.Field):
    """Validates against a given set of enumerated values."""
    def __init__(self, enum, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.enum = enum
        self.validators.insert(0, OneOf([v.value for v in self.enum]))

    def _serialize(self, value, attr, obj):
        return self.enum(value).value

    def _deserialize(self, value):
        return self.enum(value)

    def _validate(self, value):
        if type(value) is self.enum:
            super()._validate(value.value)
        else:
            super()._validate(value)

Feel free to grab some of that if it helps.

[floqqi]

I will take a look at this tomorrow. But I think Enum should be a separate field kinda like @ctolsen mentioned. Or would you prefer a validator like OneOfEnum, @sloria?

[sloria]

What advantages do you see in making it a field and not a validator?

[justanr]

I think a validator is the way to go. Maybe as a subclass of OneOf - but I've not looked at that particular code so I'm not sure if it'd work gracefully or not.

However, with a field it'd be possible to serialize/deserislize, which could very beneficial.

[justanr]

Was thinking about this today as I have a use case for it (but sadly with only DRF), but I think it might be better as an extension to marshmallow instead of included in core. If I have time this weekend, I'll knock up an example.

[justanr]

@floqqi I wrote this pretty quick, but I feel it's a decent first draft of what I'd expect this sort of thing to be.. It might fit whatever use case you had in mind.

@sloria I'm wondering if there should be like a "Marshmallow Extensions" section of the docs as there's been some nifty things coming out Issues. Not to toot my own horn, but there's been the DRF Compat library and the neat Polyfield as well.

[sloria]

@justanr Yes, I've been meaning to add an "Ecosystem" page for a while. I think the GitHub wiki would be a good place for this. I'll try to get to this soon.

[sloria]

@justanr 's marshmallow_enum solves the OP's use case, so closing this. I've added marshmallow_enum to the new Ecosystem wiki page: https://github.com/marshmallow-code/marshmallow/wiki/Ecosystem