Skip default value members on serialization

[atteneder]

Hi!

Is there a way to skip variables that are default values from serialization/dict conversion?

exampe:

@dataclass
class MyClass(DataClassJSONMixin):
    name: str = None
    soul: str = None


c = MyClass()
c.name='itseme'

print(c.to_json())

output: {"name": "itseme", "soul": null}
desired output : {"name": "itseme"}

thanks!

[atteneder]

This work-around does not work on nested member/classes though:

import json
from typing import Optional, Mapping
from types import MappingProxyType
from mashumaro import DataClassJSONMixin
from mashumaro.serializer.json import Encoder,EncodedData,DEFAULT_DICT_PARAMS,T

@dataclass
class MyClass(DataClassJSONMixin):
    name: str
    soul: str = None

    def to_json(
        self: T,
        encoder: Optional[Encoder] = json.dumps,
        dict_params: Optional[Mapping] = MappingProxyType({}),
        **encoder_kwargs) -> EncodedData:

        dct = self.to_dict(**dict(DEFAULT_DICT_PARAMS, **dict_params))

        for key,f in self.__class__.__dataclass_fields__.items():
            if dct[key] == f.default:
                dct.pop(key)

        return encoder(
            dct,
            **encoder_kwargs
        )

c=MyClass('itseme')
print(to_json())

[Fatal1ty]

Hi @atteneder

Your solution seems to work with nested classes as well.

@dataclass
class MyClassChild(MyClass, DataClassJSONMixin):
    another: str = ''

c = MyClassChild('itseme')
print(c.to_json())  # {"name": "itseme"}


@dataclass
class Parent(DataClassJSONMixin):
    a: str
    b: str = None

    def to_json(
        self: T,
        encoder: Optional[Encoder] = json.dumps,
        dict_params: Optional[Mapping] = MappingProxyType({}),
        **encoder_kwargs) -> EncodedData:

        dct = self.to_dict(**dict(DEFAULT_DICT_PARAMS, **dict_params))

        for key,f in self.__class__.__dataclass_fields__.items():
            if dct[key] == f.default:
                dct.pop(key)

        return encoder(
            dct,
            **encoder_kwargs
        )

@dataclass
class Child(Parent, DataClassJSONMixin):
    c: str = None

c = Child('a')
print(c.to_json())  # {"a": "a"}

Could you write an example of what doesn't work?

[atteneder]

Sure!

What I meant was nested dataclasses:

import json
from dataclasses import dataclass
from typing import Optional, Mapping
from types import MappingProxyType
from mashumaro import DataClassJSONMixin
from mashumaro.serializer.json import Encoder,EncodedData,DEFAULT_DICT_PARAMS,T

@dataclass
class SkipperBase(DataClassJSONMixin):
    def to_json(
        self: T,
        encoder: Optional[Encoder] = json.dumps,
        dict_params: Optional[Mapping] = MappingProxyType({}),
        **encoder_kwargs) -> EncodedData:

        dct = self.to_dict(**dict(DEFAULT_DICT_PARAMS, **dict_params))

        for key,f in self.__class__.__dataclass_fields__.items():
            if dct[key] == f.default:
                dct.pop(key)

        return encoder(
            dct,
            **encoder_kwargs
        )

@dataclass
class MyClass(SkipperBase):
    name: str
    soul: str = None

@dataclass
class MyParentClass(SkipperBase):
    child: MyClass = None

p=MyParentClass()
p.child = MyClass('itseme')
print(p.to_json())

output: {"child": {"name": "itseme", "soul": null}}
desired output: {"child": {"name": "itseme"}}

That's because the child is converted to a dict (with all default params as well) and serialized to JSON within the parent's to_json.

I guess I could override the to_dict (so that it skips default members), but that's an odd default behaviour. Ideally to_dict has a parameter for skipping default values that gets propagated to nested members.

What do you think?

[Fatal1ty]

I think the additional parameter in to_dict will solve the problem perfectly. But we need to check how much it will affect performance. Unfortunately, I don’t have enough time the next few days. It would be great if you made changes and opened a pull request. But if you don’t, I will try to find time to check it out.

[rominf]

Any updates on this? I need this too.

[atteneder]

Sorry, seems I won't have time to tinker with this.
I've been using dataclasses-json as an alternative lately. Maybe it works for this case as well.

[Fatal1ty]

It's possible to skip None values with the optional omit_none code generation flag:

from dataclasses import dataclass

from mashumaro import DataClassJSONMixin
from mashumaro.config import TO_DICT_ADD_OMIT_NONE_FLAG

@dataclass
class MyClass(DataClassJSONMixin):
    name: str = None
    soul: str = None

    class Config:
        code_generation_options = [TO_DICT_ADD_OMIT_NONE_FLAG]

c = MyClass()
c.name = 'itseme'

print(c.to_json(dict_params=dict(omit_none=True)))  # {"name": "itseme"}

At the moment this flag exists in the master branch but it will be released in the next version.

[atteneder]

Thank you very much for offering a solution!

To me this is satisfactory. It seems to not work for non-None default values, however.

@Fatal1ty Feel free to close the issue or keep it open for said shortcoming.

Again, thanks for this library!