Can I make json.dumps/loads work with Encoder/Decoder instances instead of classes?

Question

Please consider this toy example of a custom JSON-encoder.

import json
from typing import Any

class MyNumber:
    def __init__(self, num):
        self.num = num

class MultEncoder(json.JSONEncoder):
    'Multiply MyNumber instances when JSON-encoding.'

    def default(self, o: Any) -> Any:
        if isinstance(o, MyNumber):
            return o.num*2
        return super().default(o)

It works like this:

>>> json.dumps({"a": MyNumber(5)}, cls=MultEncoder)
'{"a": 10}'

My question is how can I make the factor dynamic? I would like to do:

class MultEncoder(json.JSONEncoder):
    'Multiply MyNumber instances when JSON-encoding.'
    
    def __init__(self, factor, *args, **kwargs):
        self.factor = factor        
        super().__init__(*args, **kwargs)

    def default(self, o: Any) -> Any:
        if isinstance(o, MyNumber):
            return o.num*self.factor
        return super().default(o)

But of course, json.dumps({"a": MyNumber(5)}, cls=MultEncoder(7)) fails with

TypeError: 'MultEncoder' object is not callable

because the cls argument is expected to be a class, not an instance.

edit1: Note that I cannot write custom my_json_dumps/my_json_loads functions, I can only control which encoder/decoder classes get imported in other parts of the code where json.dumps and loads are used.

edit2: Note that I tried to make a general, simple example. In my real code the encoder/decoder need to know credentials for connecting to a database and other dynamic configuration.

If you pass the factor through `MyNumber` object, does that work for you? — Mohammad Rifat Arefin, Jun 02 '22 at 16:42
@MohammadRifatArefin I'm sorry, can you clarify what you mean? — actual_panda, Jun 02 '22 at 16:43
If you add a new member `factor` in the `MyNumber` class and then use this factor in the `default` method in the `MultEncoder` class, then you can call `json.dumps` in this fashion `json.dumps({"a": MyNumber(5,7)}, cls=MultEncoder)` — Mohammad Rifat Arefin, Jun 02 '22 at 16:48
@MohammadRifatArefin ah thank you, that's clever. Unfortunately this will only work for this specific example, not in my real code where I cannot expect other programmers to set "magic attributes" on all instances of the objects that will be json-encoded. — actual_panda, Jun 02 '22 at 16:50

Mohammad Rifat Arefin · Accepted Answer · 2022-06-02T17:41:43.523

1

Make MultEncoder class instances callable by simply adding the __call__ method.

class MyNumber:
    def __init__(self, num):
        self.num = num
class MultEncoder(json.JSONEncoder):
    'Multiply MyNumber instances when JSON-encoding.'
    
    def __init__(self, factor, *args, **kwargs):
        self.factor = factor        
        super().__init__(*args, **kwargs)
    def __call__(self,**kwargs):
        return self

    def default(self, o: Any) -> Any:
        if isinstance(o, MyNumber):
            return o.num*self.factor
        return super().default(o)
json.dumps({"a": MyNumber(5)}, cls=MultEncoder(7))

And the output is:

'{"a": 35}'

edited Jun 02 '22 at 17:41

answered Jun 02 '22 at 17:14

Mohammad Rifat Arefin

399
3
10

That's so elegant! Thank you. – actual_panda Jun 03 '22 at 08:21
@actual_panda Thanks! it might be an interesting read https://stackoverflow.com/questions/48461989/python-what-does-it-mean-for-a-class-to-be-callable – Mohammad Rifat Arefin Jun 03 '22 at 15:18

score 0 · Answer 2 · answered Jun 02 '22 at 17:01

I came up with a pretty ugly solution: a class-factory function where the returned class accesses closure-variables.

def MultEncoder(factor):
    class _MultEncoder(json.JSONEncoder):
        'Multiply MyNumber instances when JSON-encoding.'

        def default(self, o: Any) -> Any:
            if isinstance(o, MyNumber):
                return o.num*factor
            return super().default(o)

    return _MultEncoder

Demo:

>>> json.dumps({"a": MyNumber(5)}, cls=MultEncoder(7))
'{"a": 35}'

Is this the best we can do here?

Can I make json.dumps/loads work with Encoder/Decoder instances instead of classes?

2 Answers2