ujson-ia 2.1.1

encode_html_chars

Used to enable special encoding of “unsafe” HTML characters into safer Unicode sequences. Default is False:

>>> ujson.dumps("<script>John&Doe", encode_html_chars=True)
'"\\u003cscript\\u003eJohn\\u0026Doe"'

ensure_ascii

Limits output to ASCII and escapes all extended characters above 127. Default is true. If your end format supports UTF-8 setting this option to false is highly recommended to save space:

>>> ujson.dumps(u"\xe5\xe4\xf6")
'"\\u00e5\\u00e4\\u00f6"'
>>> ujson.dumps(u"\xe5\xe4\xf6", ensure_ascii=False)
'"\xc3\xa5\xc3\xa4\xc3\xb6"'

escape_forward_slashes

Controls whether forward slashes (/) are escaped. Default is True:

>>> ujson.dumps("http://esn.me")
'"http:\/\/esn.me"'
>>> ujson.dumps("http://esn.me", escape_forward_slashes=False)
'"http://esn.me"'

indent

Controls whether indention (“pretty output”) is enabled. Default is 0 (disabled):

>>> ujson.dumps({"foo": "bar"})
'{"foo":"bar"}'
>>> ujson.dumps({"foo": "bar"}, indent=4)
{
    "foo":"bar"
}

pre_encode_hook

Allows to provide a custom function which is called for every encoded Python object.

The hook function semantics is similar to the standard JSONEncoder.default() method, but the pre_encode_hook() is called before any other serialization attempts, while the default() is called when all other options didn’t work.

That allows to override already exsiting behavior and define custom serialization formats for things like dates. For example:

# Default behavior: datetime is converted to timestamp
>>> ujson.dumps({"a": "foo", "b": datetime.now()})
'{"a":"foo","b":1454523657}'

# Hook is involved: the datetime object is replaced with the .isoformat() string
>>> def hook(obj):
        return obj.isoformat() if hasattr(obj, 'isoformat') else obj

>>> ujson.dumps({"a": "foo", "b": datetime.now()}, pre_encode_hook=hook)
'{"a":"foo","b":"2016-02-03T18:21:55.351081"}'

The hook may be used to replace any object with any other arbitrary object before encoding it. However, it doesn’t cancel all further encoding transformations. For example, if you return a datetime object from the hook instead of a string, it will be transformed to a timestamp.

pre_encode_primitive

The boolean flag that indicates that pre_encode_hook() should also be called for Python objects that serialized to primitive JSON types (Number, String, Boolean, null).

Usually you don’t need to define any special serialization format for these types, so the flag is false by default.

Enabling this flag may produce huge amount of pre_encode_hook() calls (the hook will be called for every single JSON value) and thus affect the performance.

precise_float

Set to enable usage of higher precision (strtod) function when decoding string to double values. Default is to use fast but less precise builtin functionality:

>>> ujson.loads("4.56")
4.5600000000000005
>>> ujson.loads("4.56", precise_float=True)
4.5599999999999996

object_hook

A custom Python function which is called after a JSON object is decoded.

The hook semantics is similar to the standard JSONDecoder.object_hook() behavior. You may use it to transform a dictionary (the decoded JSON object) into a more specific object.

For example:

>>> def hook(obj):
        if '__complex__' in obj:
            return complex(obj['real'], obj['imag'])
        return obj

>>> ujson.loads('{"__complex__": true, "real": 1, "imag": 2}', object_hook=hook)
(1+2j)

string_hook

Similar to object_hook, but called for every decoded string.

Useful for deserializing objects like dates from their textual representations, e.g.:

>>> def hook(s):
        if s.startswith('__DATE'):
            return datetime.strptime(s, '__DATE: %Y-%m-%d')
        return s

>>> ujson.loads('{"a": "foo", "b": "__DATE: 2016-01-01"}', string_hook=hook)
{'a': 'foo', 'b': datetime.datetime(2016, 1, 1, 0, 0)}