How to save a dictionary of objects?

Question

I have a Python 3.5 program that creates an inventory of objects. I created a class of Trampolines (color, size, spring, etc.). I constantly will create new instances of the class and I then save a dictionary of them. The dictionary looks like this:

my_dict = {name: instance} and the types are like so {"string": "object"}

My issue is that I want to know how to save this inventory list so that I can start where I left off the last time I closed the program.

I don't want to use pickle because I'm trying to learn secure ways to do this for more important versions in the future.

I thought about using sqlite3, so any tips on how to do this easily would be appreciated.

My preferred solution would state how to do it with the json module. I tried it, but the error I got was:

__main__.Trampoline object at 0x00032432... is not JSON serializable

Edit:

Below is the code I used when I got the error:

out_file = open(input("What do you want to save it as?  "), "w")
json.dump(my_dict, out_file, indent=4)
out_file.close()

End of Edit

I've done a good amount of research, and saw that there's also an issue with many of these save options that you can only do one object per 'save file', but that the work around to this is that you use a dictionary of objects, such as the one I made. Any info clarifying this would be great, too!

Answer 1

Here is an example of a class that handles datetime objects.

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime.datetime):
            if obj.tzinfo:
                obj = obj.astimezone(isodate.tzinfo.UTC).replace(tzinfo=None)
            return obj.isoformat()[:23] + 'Z'
        return json.JSONEncoder.default(self, obj)

when you encode to json the default function of the cls is called with object you passed. If you want to handle a type that is not part of the standard json.JSONEncoder.default you need to intercept it and return how you want it handled as a valid json type. In this example I turned the datetime into a str and returned that. If its not one of the types I want to special case, I just pass it along to the standard json.JSONEncoder.default handler.

To use this class you need to pass it in the cls param of json.dump or json.dumps:

json.dumps(obj, cls=CustomEncoder)

Decoding is done the same way but with json.JSONDecoder, json.load, and json.loads. However you can not match on type, so you will need to either add an 'hint' in encoding for decoding or know what type it needs to decode.

Answer 2

What you might be able to do is saving the instance's attributes to a CSV-file and then just create it when starting up. This might be a bit too much code and is possible not the best way. One obvious problem is that it doesn't work if you don't have the same amount of attributes as parameters, which should be possible to fix if necessary I believe. I just thought I might try and post and see if it helps :)

import json


class Trampoline:
    def __init__(self, color, size, height, spring):
        self.color = color
        self.size = size
        self.height = height
        self.spring = spring

    def __repr__(self):
        return "Attributes: {}, {}, {}, {}".format(self.color, self.size, self.height, self.spring)


my_dict = {
    "name1": Trampoline('red', 100, 2.3, True),
    "name2": Trampoline('blue', 50, 2.1, False),
    "name3": Trampoline('green', 25, 1.8, True),
    "name5": Trampoline('white', 10, 2.6, False),
    "name6": Trampoline('black', 0, 1.4, True),
    "name7": Trampoline('purple', -33, 3.0, True),
    "name8": Trampoline('orange', -999, 2.5, False),
}


def save(my_dict):
    with open('save_file.txt', 'w') as file:
        temp = {}
        for name, instance in my_dict.items():
            attributes = {}
            for attribute_name, attribute_value in instance.__dict__.items():
                attributes[attribute_name] = attribute_value
            temp[name] = attributes
        json.dump(temp, file)


def load():
    with open('save_file.txt', 'r') as file:
        my_dict = {}
        x = json.load(file)
        for name, attributes in x.items():
            my_dict[name] = Trampoline(**attributes)
    return my_dict


# CHECK IF IT WORKS!
save(my_dict)
my_dict = load()
print("\n".join(["{}  |  {}".format(name, instance) for name, instance in sorted(my_dict.items())]))

Answer 3

For a simple class, you can make an easy serializer as below. This will take all of the properties of your Trampoline object and put them into a dictionary and then into JSON.

class Trampoline(object):
    ...
    def serialize(self):
        return json.dumps(vars(self))

If your class is a bit more complicated, then write a more complicated serializer :)