Serializacja elementu członkowskiego Enum do formatu JSON

Jak serializować element Enumczłonkowski języka Python do formatu JSON, aby móc deserializować wynikowy kod JSON z powrotem do obiektu w języku Python?

Na przykład ten kod:

from enum import Enum    
import json

class Status(Enum):
    success = 0

json.dumps(Status.success)

powoduje błąd:

TypeError: <Status.success: 0> is not JSON serializable

Jak mogę tego uniknąć?

Jeśli chcesz zakodować dowolny enum.Enumelement członkowski do formatu JSON, a następnie zdekodować go jako ten sam element członkowski wyliczenia (zamiast po prostu valueatrybut elementu członkowskiego wyliczenia ), możesz to zrobić, pisząc JSONEncoderklasę niestandardową i funkcję dekodującą, która ma zostać przekazana jako object_hookargument do json.load()lub json.loads():

PUBLIC_ENUMS = {
    'Status': Status,
    # ...
}

class EnumEncoder(json.JSONEncoder):
    def default(self, obj):
        if type(obj) in PUBLIC_ENUMS.values():
            return {"__enum__": str(obj)}
        return json.JSONEncoder.default(self, obj)

def as_enum(d):
    if "__enum__" in d:
        name, member = d["__enum__"].split(".")
        return getattr(PUBLIC_ENUMS[name], member)
    else:
        return d

as_enumFunkcja polega na JSON został zakodowany z użyciem EnumEncoder, albo coś, co zachowuje się identycznie do niego.

Ograniczenie do członków PUBLIC_ENUMSjest konieczne, aby uniknąć wykorzystania złośliwie spreparowanego tekstu w celu, na przykład, oszukania wywołującego kodu do zapisania prywatnych informacji (np. Tajnego klucza używanego przez aplikację) w niepowiązanym polu bazy danych, skąd mógłby zostać ujawniony (patrz http://chat.stackoverflow.com/transcript/message/35999686#35999686 ).

Przykładowe użycie:

>>> data = {
...     "action": "frobnicate",
...     "status": Status.success
... }
>>> text = json.dumps(data, cls=EnumEncoder)
>>> text
'{"status": {"__enum__": "Status.success"}, "action": "frobnicate"}'
>>> json.loads(text, object_hook=as_enum)
{'status': <Status.success: 0>, 'action': 'frobnicate'}

Wiem, że to stare, ale czuję, że to pomoże ludziom. Właśnie przejrzałem ten dokładny problem i odkryłem, że jeśli używasz wyliczeń łańcuchowych, deklarowanie wyliczeń jako podklasy strdziała dobrze w prawie wszystkich sytuacjach:

import json
from enum import Enum

class LogLevel(str, Enum):
    DEBUG = 'DEBUG'
    INFO = 'INFO'

print(LogLevel.DEBUG)
print(json.dumps(LogLevel.DEBUG))
print(json.loads('"DEBUG"'))
print(LogLevel('DEBUG'))

Wyświetli:

LogLevel.DEBUG
"DEBUG"
DEBUG
LogLevel.DEBUG

Jak widać, ładowanie JSON generuje ciąg, DEBUGale można go łatwo przesłać z powrotem do obiektu LogLevel. Dobra opcja, jeśli nie chcesz tworzyć niestandardowego JSONEncodera.

Prawidłowa odpowiedź zależy od tego, co zamierzasz zrobić z wersją serializowaną.

Jeśli zamierzasz cofnąć serializację z powrotem do Pythona, zobacz odpowiedź Zero .

Jeśli twoja wersja serializowana jest przenoszona do innego języka, prawdopodobnie chcesz użyć IntEnumzamiast niej, który jest automatycznie serializowany jako odpowiednia liczba całkowita:

from enum import IntEnum
import json

class Status(IntEnum):
    success = 0
    failure = 1

json.dumps(Status.success)

a to zwraca:

'0'

W Pythonie 3.7 można po prostu użyć json.dumps(enum_obj, default=str)

Podobała mi się odpowiedź Zero Piraeus, ale zmodyfikowałem ją nieco do pracy z API dla Amazon Web Services (AWS) znanym jako Boto.

class EnumEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Enum):
            return obj.name
        return json.JSONEncoder.default(self, obj)

Następnie dodałem tę metodę do mojego modelu danych:

    def ToJson(self) -> str:
        return json.dumps(self.__dict__, cls=EnumEncoder, indent=1, sort_keys=True)

Mam nadzieję, że to komuś pomoże.

Jeśli używasz jsonpicklenajłatwiejszego sposobu, powinieneś wyglądać jak poniżej.

from enum import Enum
import jsonpickle


@jsonpickle.handlers.register(Enum, base=True)
class EnumHandler(jsonpickle.handlers.BaseHandler):

    def flatten(self, obj, data):
        return obj.value  # Convert to json friendly format


if __name__ == '__main__':
    class Status(Enum):
        success = 0
        error = 1

    class SimpleClass:
        pass

    simple_class = SimpleClass()
    simple_class.status = Status.success

    json = jsonpickle.encode(simple_class, unpicklable=False)
    print(json)

Po serializacji Json będziesz mieć zgodnie z oczekiwaniami {"status": 0}zamiast

{"status": {"__objclass__": {"py/type": "__main__.Status"}, "_name_": "success", "_value_": 0}}

To zadziałało dla mnie:

class Status(Enum):
    success = 0

    def __json__(self):
        return self.value

Nie musiałem niczego zmieniać. Oczywiście uzyskasz tylko wartość z tego i będziesz musiał wykonać inną pracę, jeśli chcesz później przekonwertować zserializowaną wartość z powrotem na wyliczenie.