Skip to main content

Yet another serializer of objects

Project description

yasoo: Serialize the Data You Have

Build Status codecov License: MIT Code style: black

A python serializer of attrs and dataclass objects that doesn't rely on type hints.

Why yasoo

yasoo adds type data to the serialized data, so deserialization doesn't need to rely on type hints.

Moreover, if you have a field that can contain multiple types of values, or a field which contains some specific implementation of an abstract class, yasoo has no problem with that.

For example, this code works fine:

from attr import attrs, attrib
from yasoo import serialize, deserialize

class Foo:
    a = attrib()

class Bar:
    foo: Foo = attrib()

serialized = serialize(Bar(foo=5))
assert(deserialize(serialized).foo == 5)


Basic Usage

For simple objects, use:

from yasoo import serialize, deserialize

with open(path, 'w') as f:
    json.dump(serialize(obj), f)

with open(path) as f:
    obj = deserizlie(json.load(f))

Advanced Usage

Custom (De)Serializers

For objects that need custom serialization/deserialization, you can register your own methods:

from attr import attrs, attrib, asdict
from yasoo import serialize, deserialize, serializer, deserializer

class Foo:
    bar = attrib(converter=lambda x: x * 2)

    def set_foobar(self, foobar):
        self.foobar = foobar

    def serialize(self: 'Foo'):
        result = asdict(self)
        if hasattr(self, 'foobar'):
            result['foobar'] = self.foobar
        return result

    def deserialize(data: dict) -> 'Foo':
        foo = Foo(data['bar'] / 2)
        if 'foobar' in data:
        return foo

Notice that registering custom methods with forward reference (i.e. 'Foo' instead of Foo) requires passing the globals parameter to serialize/deserialize, e.g.

serialize(obj, globals=globals())

Using Type Hints

If you want to avoid having the __type key in your serialized data, you can set the type_key parameter to False when calling serialize.

For this to work all fields in the serialized class that are not json-serializable should have a type hint.

Multiple Serialization Methods For The Same Type

If you want to define a custom serialization method for a type for a specific use case, without affecting the default serializer, you can create another instance of Serializer and register the method on that instance. For example:

from yasoo import Serializer, serializer, serialize

def serialize_foo(foo: Foo):
    return {'bar':}

my_serializer = Serializer()

def serialize_foo_another_way(foo: Foo):
    return {'bar': * 2}

serialize(Foo(bar=5))  # returns {'bar': 5, '__type': 'Foo'}
my_serializer.serialize(Foo(bar=5))  # returns {'bar': 10, '__type': 'Foo'}

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for yasoo, version 0.1.6
Filename, size File type Python version Upload date Hashes
Filename, size yasoo-0.1.6-py3-none-any.whl (8.3 kB) File type Wheel Python version py3 Upload date Hashes View
Filename, size yasoo-0.1.6.tar.gz (6.6 kB) File type Source Python version None Upload date Hashes View

Supported by

Pingdom Pingdom Monitoring Google Google Object Storage and Download Analytics Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page