Serializzare un Python namedtuple in json

Qual è il modo consigliato per serializzare un namedtuplein json mantenendo i nomi dei campi?

La serializzazione di a namedtuplein json comporta la serializzazione solo dei valori e la perdita dei nomi dei campi nella traduzione. Vorrei che i campi venissero mantenuti anche quando json-ized e quindi ha fatto quanto segue:

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

Quanto sopra serializza in json come mi aspetto e si comporta come namedtuplein altri posti che uso (accesso agli attributi ecc.) Tranne che con risultati non simili a tupla durante l'iterazione (che va bene per il mio caso d'uso).

Qual è il "modo corretto" di convertire in json mantenendo i nomi dei campi?

Questo è piuttosto complicato, poiché namedtuple()è una fabbrica che restituisce un nuovo tipo derivato da tuple. Un approccio potrebbe essere quello di far ereditare anche la tua classe da UserDict.DictMixin, ma tuple.__getitem__è già definita e si aspetta un numero intero che denoti la posizione dell'elemento, non il nome del suo attributo:

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

Fondamentalmente namedtuple è una scelta strana per JSON, poiché è in realtà un tipo personalizzato i cui nomi di chiave sono fissati come parte della definizione del tipo , a differenza di un dizionario in cui i nomi di chiave sono memorizzati all'interno dell'istanza. Questo ti impedisce di eseguire il "round trip" di una namedtuple, ad esempio non puoi decodificare un dizionario in una namedtuple senza qualche altra informazione, come un marcatore di tipo specifico dell'app nel dict {'a': 1, '#_type': 'foobar'}, che è un po 'hacky.

Questo non è l'ideale, ma se hai solo bisogno di codificare namedtuples in dizionari, un altro approccio è estendere o modificare il tuo codificatore JSON a questi tipi di casi speciali. Ecco un esempio di sottoclasse di Python json.JSONEncoder. Questo affronta il problema di garantire che le coppie denominate annidate siano convertite correttamente in dizionari:

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"}}

Se è solo uno namedtupleche stai cercando di serializzare, il suo _asdict()metodo funzionerà (con 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}'

Sembra che tu fossi in grado di simplejson.JSONEncodercreare sottoclassi per farlo funzionare, ma con l'ultimo codice simplejson, non è più così: devi effettivamente modificare il codice del progetto. Non vedo alcun motivo per cui simplejson non dovrebbe supportare namedtuples, quindi ho biforcato il progetto, aggiunto il supporto namedtuple e sto attualmente aspettando che il mio ramo venga riportato nel progetto principale . Se hai bisogno delle correzioni ora, tira fuori dalla mia forcella.

EDIT : Sembra che le ultime versioni di simplejsonora supportino nativamente questo con l' namedtuple_as_objectopzione, che per impostazione predefinita è True.

Ho scritto una libreria per farlo: https://github.com/ltworf/typedload

Può andare da e a tupla con nome e viceversa.

Supporta strutture annidate piuttosto complicate, con elenchi, insiemi, enumerazioni, unioni, valori predefiniti. Dovrebbe coprire i casi più comuni.

modifica: la libreria supporta anche dataclass e classi attr.

Converte in modo ricorsivo i dati namedTuple in 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'}

C'è una soluzione più conveniente è utilizzare il decoratore (utilizza il campo protetto _fields).

Python 2.7+:

import json
from collections import namedtuple, OrderedDict

def json_serializable(cls):
    def as_dict(self):
        yield OrderedDict(
            (name, value) for name, value in zip(
                self._fields,
                iter(super(cls, self).__iter__())))
    cls.__iter__ = as_dict
    return cls

#Usage:

C = json_serializable(namedtuple('C', 'a b c'))
print json.dumps(C('abc', True, 3.14))

# or

@json_serializable
class D(namedtuple('D', 'a b c')):
    pass

print json.dumps(D('abc', True, 3.14))

Python 3.6.6 e versioni successive:

import json
from typing import TupleName

def json_serializable(cls):
    def as_dict(self):
        yield {name: value for name, value in zip(
            self._fields,
            iter(super(cls, self).__iter__()))}
    cls.__iter__ = as_dict
    return cls

# Usage:

@json_serializable
class C(NamedTuple):
    a: str
    b: bool
    c: float

print(json.dumps(C('abc', True, 3.14))

La libreria jsonplus fornisce un serializzatore per le istanze NamedTuple. Usa la sua modalità di compatibilità per produrre oggetti semplici se necessario, ma preferisci l'impostazione predefinita in quanto è utile per la decodifica.

È impossibile serializzare correttamente le namedtuples con la libreria json nativa di Python. Vedrà sempre le tuple come elenchi ed è impossibile sovrascrivere il serializzatore predefinito per modificare questo comportamento. È peggio se gli oggetti sono nidificati.

Meglio usare una libreria più robusta come orjson :

import orjson
from typing import NamedTuple

class Rectangle(NamedTuple):
    width: int
    height: int

def default(obj):
    if hasattr(obj, '_asdict'):
        return obj._asdict()

rectangle = Rectangle(width=10, height=20)
print(orjson.dumps(rectangle, default=default))

=>

{
    "width":10,
    "height":20
}

Questa è una vecchia domanda. Però:

Un suggerimento per tutti coloro che hanno la stessa domanda, pensa attentamente all'utilizzo di qualsiasi caratteristica privata o interna del NamedTupleperché hanno prima e cambieranno di nuovo nel tempo.

Ad esempio, se il tuo NamedTupleè un oggetto di valore flat e sei interessato solo a serializzarlo e non nei casi in cui è annidato in un altro oggetto, potresti evitare i problemi che potrebbero sorgere con la __dict__rimozione o la _as_dict()modifica e fai semplicemente qualcosa di simile (e sì, questo è Python 3 perché questa risposta è per il momento):

from typing import NamedTuple

class ApiListRequest(NamedTuple):
  group: str="default"
  filter: str="*"

  def to_dict(self):
    return {
      'group': self.group,
      'filter': self.filter,
    }

  def to_json(self):
    return json.dumps(self.to_dict())

Ho provato a utilizzare il defaultkwarg richiamabile dumpsper per eseguire la to_dict()chiamata se disponibile, ma non è stato chiamato in quanto NamedTupleè convertibile in un elenco.

Ecco la mia opinione sul problema. Serializza la NamedTuple, si prende cura delle NamedTuples e degli elenchi piegati al loro interno

def recursive_to_dict(obj: Any) -> dict:
_dict = {}

if isinstance(obj, tuple):
    node = obj._asdict()
    for item in node:
        if isinstance(node[item], list): # Process as a list
            _dict[item] = [recursive_to_dict(x) for x in (node[item])]
        elif getattr(node[item], "_asdict", False): # Process as a NamedTuple
            _dict[item] = recursive_to_dict(node[item])
        else: # Process as a regular element
            _dict[item] = (node[item])
return _dict

simplejson.dump()invece di json.dumpfare il lavoro. Potrebbe essere più lento però.