CODEWITHSUNDEEP
pythonjson
Stephane Rolland
Stephane Rolland

Reputation: 39906

Pythonic json serialisation

I have tried to have a decent business layer that is server side. Less work possible for each new business class to be stored in the database.

However, it doesn't perform the convertion to json very well. It works for simple python object, using json.dumps(self.__dict__). But a list of simple python objects does not serialize to json very well.

When performing a json serialization of a list I try to return json.dumps([x.to_json() for x in self.my_list_items]) but it outputs additionnal double quotes, and \" for each item in the list: ["{\"completed\": 0, \"id\": 1, \"name\": \"labelOne\"}", "{\"completed\": 0, \"id\": 2, \"name\": \"Label2\"}"]

This is the code I use:

class JSONizable(object):
    def to_json(self):
        return json.dumps(self.__dict__)    

class Task(JSONizable):
    def __init__(self):
        self.id = -1
        self.name = "new task"
        self.completed = 1

    def load_sql(self, sql):
        #do things

class Tasks(JSONizable):
    def __init__(self):
        self.tasks=[]

    def load_sql(self,sql):
        #do things

    def to_json(self):
       return json.dumps([x.to_json() for x in self.tasks]) # things go bad here

Could you suggest a more pythonic way to perform json serialization for python object, when such object contains lists of items ?

Upvotes: 3

Views: 419

Answers (4)

Stephane Rolland
Stephane Rolland

Reputation: 39906

Combining njzk2's and freakish's answers, I ended up with a solution that does the job nicely.

import json
import database

class JSONizable(object):
    def to_json(self):
        return json.dumps(self.to_serializable())
    def to_serializable(self):
        return  self.__dict__

class Task(JSONizable):
    def __init__(self):
        self.id = -1
        self.name = "new task"
        self.completed = 1

    def load_sql(self, sql):
        #...

class Tasks(JSONizable):
    def __init__(self):
        self.tasks=[]

    def load_sql(self,sql):
        #...

    def to_serializable(self):
        return [x.to_serializable() for x in self.tasks]

def get_json_tasks():
    db = database.db
    tasks = Tasks()
    tasks.load_sql(db.get_sql_tasks())
    return tasks.to_json()

It outputs in proper Json format: [{"completed": 0, "id": 1, "name": "labelOne"}, {"completed": 0, "id": 2, "name": "labelTwo"}, {"completed": 0, "id": 3, "name": "LabelThree"}] just like I needed.

Upvotes: 2

njzk2
njzk2

Reputation: 39386

your to_json formats as json. returning the __dict__ is sufficient :

class JSONizable(object):
    def to_json(self):
        return self.__dict__

Upvotes: 1

freakish
freakish

Reputation: 56467

The problem is that you are serializing twice. Once in x.to_json() and second time when you create a list and serialize it in Tasks.to_json. I suggest you convert to dicts instead of JSON:

class Task(JSONizable):
    def to_serializable(self):
        return {
            # some JSON serializable data here
            "id": self.id,
            "name": self.name,
            "completed": self.completed
        }

class Tasks(JSONizable):
    def to_serializable(self):
        return [x.to_serializable() for x in self.tasks]

and then when you have an instance of Tasks class:

TasksInstance = Tasks()
json.dumps(TasksInstance.to_serializable())

By the way: using self.__dict__ might not work anyway, since an instance of JSONizable may contain non-serializable attributes, for example an instance of another class.

Upvotes: 1

vartec
vartec

Reputation: 134581

Actually the only working solution to this is bit ugly and IMHO unpythonic.

The solution is to extend JSONEncoder overriding its default() method:

import json

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if not isinstance(obj, Task):
            return super(CustomEncoder, self).default(obj)
        return obj.__dict__

json.dumps(list_of_tasks, cls=CustomEncoder)

Upvotes: 2

Related Questions