Skip to main content

Custom datatypes (like datetime) serialization to/from JSON.

Project description

Serialization of Python types to JSON that “just works”.

Forget errors like:

TypeError: datetime.datetime(...) is not JSON serializable

In addition to (de-)serialization of basic types (provided by simplejson), jsonplus provides support for exact (de-)serialization of other commonly used types, like: tuple/namedtuple, set/frozenset, complex/decimal.Decimal/fractions.Fraction, and datetime/date/time/timedelta.

If the exact representation of types is not your cup of tea, and all you wish for is the json.dumps to work on your data structure with non-basic types, accepting the loss of “type-precision” along the way, than you can use the compatibility mode (thread-local jsonplus.prefer_compat(), or per-call override jsonplus.dumps(..., exact=False)).


jsonplus is available as a Python package. To install it, simply type:

$ pip install jsonplus


You can treat jsonplus as a friendly drop-in replacement for json/simplejson.

>>> import jsonplus as json

>>> x = json.loads('{"a":1,"b":2}')
>>> y = json.dumps(x, indent=4)
>>> z = json.pretty(x)


Let’s start with that beloved datetime.

>>> import jsonplus as json

>>> from datetime import datetime
>>> json.dumps({
...     "x": [4,3],
...     "t":
... })

>>> json.loads(_)
{u'x': [4, 3], u't': datetime.datetime(2013, 9, 6, 23, 38, 55, 819791)}

Similarly for other datetime.* types, like timedelta, date, and time:

>>> from datetime import timedelta, date, time
>>> print(json.pretty({"dt": timedelta(0, 1234567, 123), "d":, "t":}))
    "d": {
        "__class__": "date",
        "__value__": "2013-09-22"
    "dt": {
        "__class__": "timedelta",
        "__value__": {
            "days": 14,
            "microseconds": 123,
            "seconds": 24967
    "t": {
        "__class__": "time",
        "__value__": "23:33:16.335360"

Also, set and complex:

>>> json.dumps([set(range(3)), 1+2j])

>>> json.loads(_)
[set([0, 1, 2]), (1+2j)]

tuple and namedtuple are also preserved:

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])

>>> data = json.pretty({"vect": (1, 2, 3), "dot": Point(3, 4)})
>>> print(data)
    "dot": {
        "__class__": "namedtuple",
        "__value__": {
            "fields": [
            "name": "Point",
            "values": [
    "vect": {
        "__class__": "tuple",
        "__value__": [

>>> json.loads(data)
{'vect': (1, 2, 3), 'dot': Point(x=3, y=4)}

Compatibility mode

All types supported in the exact mode are also supported in the compatibility mode. JSON representation differs, however.

In the exact mode, type and value are encoded with JSON Object’s __class__ and __value__ keys, while in the compatibility mode, values are “rounded off” to the closest JSON type.

For example, tuple and set are represented with JSON Array, and namedtuple is coded as a plain JSON Object. Decimal is represented as JSON Number with arbitrary precision (which is lost if decoded as float).

To switch between the exact and compatibility modes, use the (thread-local) functions prefer_exact() and prefer_compat(), or call dumps(..., exact=False):

>>> import jsonplus as json

>>> json.prefer_compat()
# or:
>>> json.prefer(json.COMPAT)
# per-instance override:
>>> json.dumps(obj, exact=False)

# to go back to (default) exact coding:
>>> json.prefer_exact()

The above tuple/namedtuple/datetime examples run in the compatibility coding mode result with:

>>> json.prefer_compat()

>>> print(json.pretty({"vect": (1, 2, 3), "dot": Point(3, 4)}))
    "point": {
        "x": 3,
        "y": 4
    "vector": [

>>> json.dumps({"now":})

So, to be able to properly decode values in the compatibility mode, some additional context will have to be provided to the decoder.

Adding user types

Support for user/custom types can easily be added with @jsonplus.encoder and @jsonplus.decoder decorators.

For example, to enable serialization of your type named mytype in exact mode (to add compat-mode serialization, append exact=False in decorator):

def mytype_exact_encoder(myobj):
    return myobj.to_json()
def mytype_decoder(value):
    return mytype(value, reconstruct=True, ...)

If detection of object class is more complex than a simple classname comparison, if you need to use a predicate function, simply add predicate=... to the encoder decorator. For example:

@jsonplus.encoder('BaseClass', lambda obj: isinstance(obj, BaseClass))
def all_derived_classes_encoder(derived):
    return derived.base_encoder()

Project details

Download files

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

Source Distribution

jsonplus-0.8.0.tar.gz (9.2 kB view hashes)

Uploaded Source

Built Distribution

jsonplus-0.8.0-py2.py3-none-any.whl (11.5 kB view hashes)

Uploaded Python 2 Python 3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page