Sérialisation d'un namedtuple Python en json

Question

Quelle est la méthode recommandée pour sérialiser un namedtuple en json avec les noms de champs conservés ?

Sérialisation d'un namedtuple en json, seules les valeurs sont sérialisées et les noms des champs sont perdus dans la traduction. Je voudrais que les champs soient également conservés lors de la conversion en json et j'ai donc procédé comme suit :

class foobar(namedtuple('f', 'foo, bar')):
    __slots__ = ()
    def __iter__(self):
        yield self._asdict()

Ce qui précède est sérialisé en json comme prévu et se comporte comme suit namedtuple dans d'autres endroits où je l'utilise (accès aux attributs, etc.), sauf avec des résultats non-tuple comme ceux de l'itération (ce qui convient à mon cas d'utilisation).

Quelle est la "bonne méthode" pour convertir en json en conservant les noms des champs ?

Answer 1

Si c'est juste un namedtuple que vous cherchez à sérialiser, en utilisant sa fonction _asdict() La méthode fonctionnera (avec Python >= 2.7)

>>> from collections import namedtuple
>>> import json
>>> FB = namedtuple("FB", ("foo", "bar"))
>>> fb = FB(123, 456)
>>> json.dumps(fb._asdict())
'{"foo": 123, "bar": 456}'

Answer 2

C'est assez délicat, car namedtuple() est une usine qui renvoie un nouveau type dérivé de tuple . Une approche consisterait à faire en sorte que votre classe hérite également de UserDict.DictMixin mais tuple.__getitem__ est déjà défini et attend un nombre entier indiquant la position de l'élément, et non le nom de son attribut :

>>> f = foobar('a', 1)
>>> f[0]
'a'

À la base, le namedtuple est étrangement adapté à JSON, puisqu'il s'agit en fait d'un fichier de type type personnalisé dont les noms de clés sont fixés dans le cadre de la définition du type contrairement à un dictionnaire où les noms des clés sont stockés dans l'instance. Cela vous empêche de "faire le tour" d'un namedtuple, c'est-à-dire que vous ne pouvez pas décoder un dictionnaire en un namedtuple sans une autre information, comme un marqueur de type spécifique à l'application dans le dict. {'a': 1, '#_type': 'foobar'} ce qui est un peu compliqué.

Ce n'est pas idéal, mais si vous avez seulement besoin de coder Une autre approche consiste à étendre ou à modifier votre encodeur JSON pour qu'il tienne compte de ces types. Voici un exemple de sous-classement du codeur Python json.JSONEncoder . Cela permet de s'assurer que les namedtuples imbriqués sont correctement convertis en dictionnaires :

from collections import namedtuple
from json import JSONEncoder

class MyEncoder(JSONEncoder):

    def _iterencode(self, obj, markers=None):
        if isinstance(obj, tuple) and hasattr(obj, '_asdict'):
            gen = self._iterencode_dict(obj._asdict(), markers)
        else:
            gen = JSONEncoder._iterencode(self, obj, markers)
        for chunk in gen:
            yield chunk

class foobar(namedtuple('f', 'foo, bar')):
    pass

enc = MyEncoder()
for obj in (foobar('a', 1), ('a', 1), {'outer': foobar('x', 'y')}):
    print enc.encode(obj)

{"foo": "a", "bar": 1}
["a", 1]
{"outer": {"foo": "x", "bar": "y"}}

Answer 3

Il semble que vous pouviez autrefois sous-classer simplejson.JSONEncoder pour que cela fonctionne, mais avec le dernier code de simplejson, ce n'est plus le cas : il faut en fait modifier le code du projet. Je ne vois pas pourquoi simplejson ne devrait pas supporter les namedtuple, donc j'ai bifurqué le projet, ajouté le support des namedtuple, et je suis J'attends actuellement que ma branche soit réintégrée dans le projet principal. . Si vous avez besoin des réparations maintenant, il suffit de tirer de ma fourchette.

EDIT : Il semble que les dernières versions de simplejson le supportent désormais de manière native avec l namedtuple_as_object qui a pour valeur par défaut True .

Answer 4

J'ai écrit une bibliothèque pour faire cela : https://github.com/ltworf/typedload

Il peut passer de and à named-tuple et inversement.

Il supporte des structures imbriquées assez complexes, avec des listes, des ensembles, des enums, des unions, des valeurs par défaut. Il devrait couvrir les cas les plus courants.

edit : La bibliothèque supporte également les classes dataclass et attr.

Answer 5

Il convertit récursivement les données namedTuple en json.

print(m1)
## Message(id=2, agent=Agent(id=1, first_name='asd', last_name='asd', mail='2@mai.com'), customer=Customer(id=1, first_name='asd', last_name='asd', mail='2@mai.com', phone_number=123123), type='image', content='text', media_url='h.com', la=123123, ls=4512313)

def reqursive_to_json(obj):
    _json = {}

    if isinstance(obj, tuple):
        datas = obj._asdict()
        for data in datas:
            if isinstance(datas[data], tuple):
                _json[data] = (reqursive_to_json(datas[data]))
            else:
                 print(datas[data])
                _json[data] = (datas[data])
    return _json

data = reqursive_to_json(m1)
print(data)
{'agent': {'first_name': 'asd',
'last_name': 'asd',
'mail': '2@mai.com',
'id': 1},
'content': 'text',
'customer': {'first_name': 'asd',
'last_name': 'asd',
'mail': '2@mai.com',
'phone_number': 123123,
'id': 1},
'id': 2,
'la': 123123,
'ls': 4512313,
'media_url': 'h.com',
'type': 'image'}