Serializando um Python nomeado duplamente para json

Qual é a maneira recomendada de serializar um namedtuplepara json com os nomes de campo retidos?

Serializar a namedtuplepara json resulta na serialização apenas dos valores e na perda dos nomes dos campos na tradução. Eu gostaria que os campos também fossem mantidos quando jsonizados e, portanto, fiz o seguinte:

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

O código acima é serializado para json conforme eu espero e se comporta como namedtupleem outros lugares que eu uso (acesso de atributo, etc.), exceto com resultados não-tupla durante a iteração (o que é bom para meu caso de uso).

Qual é a "maneira correta" de converter para JSON com os nomes dos campos retidos?

Isso é bastante complicado, pois namedtuple()é uma fábrica que retorna um novo tipo derivado de tuple. Uma abordagem seria fazer com que sua classe também herde de UserDict.DictMixin, mas tuple.__getitem__já está definida e espera um número inteiro denotando a posição do elemento, não o nome de seu atributo:

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

Em sua essência, o namedtuple é um ajuste estranho para JSON, pois é realmente um tipo customizado cujos nomes de chave são fixados como parte da definição de tipo , ao contrário de um dicionário onde os nomes de chave são armazenados dentro da instância. Isso evita que você faça um "round-trip" de um namedtuple, por exemplo, você não pode decodificar um dicionário de volta para um namedtuple sem alguma outra informação, como um marcador de tipo específico do aplicativo no dicionário {'a': 1, '#_type': 'foobar'}, que é um pouco hackeado.

Isso não é o ideal, mas se você só precisa codificar namedtuples em dicionários, outra abordagem é estender ou modificar seu codificador JSON para casos especiais desses tipos. Aqui está um exemplo de subclasse de Python json.JSONEncoder. Isso resolve o problema de garantir que as duplicatas nomeadas aninhadas sejam convertidas corretamente em dicionários:

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 for apenas um que namedtuplevocê deseja serializar, usar seu _asdict()método funcionará (com 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}'

Parece que você costumava ser capaz de criar uma subclasse simplejson.JSONEncoderpara fazer isso funcionar, mas com o código simplejson mais recente, esse não é mais o caso: você realmente tem que modificar o código do projeto. Não vejo razão para que o simplejson não deva oferecer suporte a namedtuples, então eu fiz um fork do projeto, adicionei o suporte namedtuple e estou atualmente esperando que meu branch seja puxado de volta para o projeto principal . Se você precisar de correções agora, basta puxar do meu garfo.

EDITAR : Parece que as versões mais recentes do simplejsonagora suportam nativamente isso com a namedtuple_as_objectopção, cujo padrão é True.

Eu escrevi uma biblioteca para fazer isso: https://github.com/ltworf/typedload

Ele pode ir de e para tupla nomeada e voltar.

Ele suporta estruturas aninhadas bastante complicadas, com listas, conjuntos, enums, uniões, valores padrão. Deve abranger os casos mais comuns.

editar: A biblioteca também oferece suporte a classes de dados e classes de atributos.

Ele converte recursivamente os dados namedTuple em json.

print(m1)
## Message(id=2, agent=Agent(id=1, first_name='asd', last_name='asd', mail='[email protected]'), customer=Customer(id=1, first_name='asd', last_name='asd', mail='[email protected]', 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': '[email protected]',
'id': 1},
'content': 'text',
'customer': {'first_name': 'asd',
'last_name': 'asd',
'mail': '[email protected]',
'phone_number': 123123,
'id': 1},
'id': 2,
'la': 123123,
'ls': 4512313,
'media_url': 'h.com',
'type': 'image'}

Existe uma solução mais conveniente é usar o decorador (ele usa o campo protegido _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+:

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))

A biblioteca jsonplus fornece um serializador para instâncias NamedTuple. Use seu modo de compatibilidade para gerar objetos simples, se necessário, mas prefira o padrão, pois é útil para a decodificação de volta.

É impossível serializar namedtuples corretamente com a biblioteca python json nativa. Ele sempre verá as tuplas como listas, e é impossível substituir o serializador padrão para alterar esse comportamento. É pior se os objetos estiverem aninhados.

Melhor usar uma biblioteca mais robusta como 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
}

Esta é uma velha questão. Contudo:

Uma sugestão para todos aqueles com a mesma pergunta, pense cuidadosamente sobre como usar qualquer um dos recursos privados ou internos do NamedTupleporque eles já o fizeram e irão mudar novamente com o tempo.

Por exemplo, se seu NamedTupleé um objeto de valor plano e você está interessado apenas em serializá-lo e não nos casos em que está aninhado em outro objeto, você pode evitar os problemas que surgiriam com __dict__a remoção ou _as_dict()alteração e apenas fazer algo como (e sim, este é Python 3 porque esta resposta é para o presente):

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())

Tentei usar o defaultcallable kwarg to dumpspara fazer a to_dict()chamada, se disponível, mas não foi chamado porque NamedTupleé conversível para uma lista.

Aqui está minha opinião sobre o problema. Ele serializa a NamedTuple, cuida das NamedTuples e Listas dobradas dentro delas

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()em vez de json.dumpfazer o trabalho. Pode ser mais lento.