serialize/deserialize data from/to json

[bb8]

so i have some classes

class Record:
    def __init__(self, a, b, c):
        # a, b, c are strings
        self.a = a
        self.b = b
        self.c = c

class Info:
    def __init__(self, t, d):
        # t, d are strings
        self.t = t
        self.d = d

class Containter:
    def __init__(self):
        self.infos = {} # str to Info hash
        self.storage = {} # str to (str to list of Records) hash

for example, instance of a container:

{"r1": {"c1": [Record("a", "b", "c"), Record("h", "u", "e")],
        "c2": [Record("t", "b", "r"), Record("q", "o", "m")]
       },

"r2": {"c3": [Record("c", "j", "m"), Record("h", "u", "e")]
      }
}

i tried to use jsonpickle but the output isn't simple to store in file and then deserialize

i read about subclassing jsonencoder, but i could do it only for record class, not container

[Gribouillis]

I think it is an interesting question, so I wrote this script. It is certainly not terse code, but it works!

from functools import singledispatch
import json

class Record:
    def __init__(self, a, b, c):
        # a, b, c are strings
        self.a = a
        self.b = b
        self.c = c
 
class Info:
    def __init__(self, t, d):
        # t, d are strings
        self.t = t
        self.d = d
 
class Container:
    def __init__(self):
        self.infos = {} # str to Info hash
        self.storage = {} # str to (str to list of Records) hash

'''
example
{"r1": {"c1": [Record("a", "b", "c"), Record("h", "u", "e")],
        "c2": [Record("t", "b", "r"), Record("q", "o", "m")]
       },
 
"r2": {"c3": [Record("c", "j", "m"), Record("h", "u", "e")]
      }
}
'''

############# Encoding ##############

class CannotConvert(Exception):
    pass

@singledispatch
def my_converter(ob):
    raise CannotConvert

@my_converter.register(Container)
def _(ob):
    return {
        'my_type': 'Container',
        'infos': ob.infos,
        'storage': ob.storage,
    }

@my_converter.register(Record)
def _(ob):
    return {
        'my_type': 'Record',
        'a': ob.a,
        'b': ob.b,
        'c': ob.c,
    }

@my_converter.register(Info)
def _(ob):
    return {
        'my_type': 'Info',
        't': ob.t,
        'd': ob.d,
    }


class MyEncoder(json.JSONEncoder):
    def default(self, ob):
        try:
            return my_converter(ob)
        except CannotConvert:
            pass
        return json.JSONEncoder.default(self, ob)

############## Decoding #################

builders = {}

def builder(tp):
    def decorator(func):
        builders[tp] = func
        return func
    return decorator

def my_hook(pairs):
    dic = dict(pairs)
    try:
        typename = dic['my_type']
        tp = {
            'Container': Container,
            'Info': Info,
            'Record': Record,
        }[typename]
    except KeyError:
        return dic
    dic.pop('my_type')
    return builders[tp](dic)


@builder(Record)
def _(dic):
    return Record(dic['a'], dic['b'], dic['c'])

@builder(Info)
def _(dic):
    return Info(dic['t'], dic['d'])

@builder(Container)
def _(dic):
    ob = Container()
    for k in ('infos', 'storage'):
        setattr(ob, k, dic[k])
    return ob



kont = Container()
kont.storage['r1'] = {
    'c1': [Record('a', 'b', 'c'), Record('h', 'u', 'e')],
    'c2': [Record('t', 'b', 'r'), Record('q', 'o', 'm')],
}
kont.storage['r2'] = {
    'c3': [Record('c', 'j', 'm'), Record('h', 'u', 'e')],
}
kont.infos['i1'] = Info('foo', 'bar')
kont.infos['i2'] = Info('baz', 'qux')

s = json.dumps(kont, cls=MyEncoder)
print(s)
c = json.loads(s, object_pairs_hook=my_hook)
print(c)
print(c.infos)
print(c.storage)