Exposed functions and symbols

• dumps() function
• dump() function
• loads() function
• load() function
• Encoder class
• Decoder class
• Validator class
• RawJSON class

rapidjson.__author__

The authors of the module.

rapidjson.__version__

The version of the module.

rapidjson.__rapidjson_version__

The version of the RapidJSON library this module is built with.

rapidjson.__rapidjson_exact_version__

The exact version of the RapidJSON library, as determined by git describe.

datetime_mode related constants

rapidjson.DM_NONE

This is the default datetime_mode: neither date nor datetime nor time instances are recognized by dumps() and loads().

rapidjson.DM_ISO8601

In this datetime_mode mode dumps() and loads() handle date, datetime and date instances representing those values using the ISO 8601 format.

rapidjson.DM_UNIX_TIME

This mode tells RapidJSON to serialize date, datetime and time as numeric timestamps: for the formers it is exactly the result of their timestamp() method, that is as the number of seconds passed since EPOCH; date instances are serialized as the corresponding datetime instance with all the time slots set to 0; time instances are serialized as the number of seconds since midnight.

Since this is obviously irreversible, this flag is usable only for dumps(): an error is raised when passed to loads().

rapidjson.DM_ONLY_SECONDS

This is usable in combination with DM_UNIX_TIME so that an integer representation is used, ignoring microseconds.

rapidjson.DM_IGNORE_TZ

This can be used combined with DM_ISO8601 or DM_UNIX_TIME, to ignore the value’s timezones.

rapidjson.DM_NAIVE_IS_UTC

This can be used combined with DM_ISO8601 or DM_UNIX_TIME, to tell RapidJSON that the naïve values (that is, without an explicit timezone) are already in UTC timezone.

rapidjson.DM_SHIFT_TO_UTC

This can be used combined with DM_ISO8601 or DM_UNIX_TIME, to always shift values the UTC timezone.

uuid_mode related constants

rapidjson.UM_NONE

This is the default uuid_mode: UUID instances are not recognized by dumps() and loads().

rapidjson.UM_CANONICAL

In this uuid_mode, loads() recognizes string values containing the xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx canonical representation as UUID instances; dumps() emits same kind of representation for UUID instances as a string value.

rapidjson.UM_HEX

In this uuid_mode loads() recognizes string values containing exactly 32 hex digits or the xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx canonical representation as UUID instances; dumps() emits the 32 hex digits of UUID instances as a string value.

number_mode related constants

rapidjson.NM_NONE

This is the default number_mode: numeric values can be as wide as the memory allows.

rapidjson.NM_DECIMAL

In this number_mode loads() will return floating point values as Decimal instances instead of float; dumps() will serialize Decimal instances like any other float number.

rapidjson.NM_NAN

This enables non-numbers (i.e. nan, +inf and -inf) handling in both directions.

rapidjson.NM_NATIVE

In this alternative number_mode numeric values must fit into the underlying C library limits, with a considerable speed benefit.

parse_mode related constants

rapidjson.PM_NONE

This is the default parse_mode: with the exception of the NaN and Infinite recognition active by default, the parser is in strict mode.

rapidjson.PM_COMMENTS

In this parse_mode, the parser allows and ignores one-line // ... and multi-line /* ... */ comments

rapidjson.PM_TRAILING_COMMAS

In this parse_mode, the parser allows and ignores trailing commas at the end of arrays and objects.

bytes_mode related constants

rapidjson.BM_NONE

This disables the default handling mode (BM_UTF8) of bytes instances: they won’t be treated in any special way and will raise a TypeError exception when encountered. On the other hand, in this mode they can be managed by a default handler.

rapidjson.BM_UTF8

This is the default setting for bytes_mode: any bytes instance will be assumed to be an UTF-8 encoded string, and decoded accordingly.

iterable_mode related constants

rapidjson.IM_ANY_ITERABLE

This is the default setting for iterable_mode: any iterable will be dumped as a JSON array.

rapidjson.IM_ONLY_LISTS

This disables the default handling mode (IM_ANY_ITERABLE) of iterable values (with the exception of strings and lists): they won’t be treated in any special way and will raise a TypeError exception when encountered. On the other hand, in this mode they can be managed by a default handler.

mapping_mode related constants

rapidjson.MM_ANY_MAPPING

This is the default setting for mapping_mode: any mapping will be dumped as a JSON object.

rapidjson.MM_ONLY_DICTS

This disables the default handling mode (MM_ANY_MAPPING) of generic mapping values, they won’t be treated like dicts and will raise a TypeError exception when encountered. On the other hand, in this mode they can be managed by a default handler.

rapidjson.MM_COERCE_KEYS_TO_STRINGS

Since JSON objects require that all keys must be of type string, when a mapping contains non-string keys, it will be processed by the default handler if available, otherwise a TypeError exception is raised.

Alternatively, you can use the this option to automatically render such keys as their str() representation.

rapidjson.MM_SKIP_NON_STRING_KEYS

In this mode, dict keys that are not of a basic type (str, int, float, bool, None) will be skipped instead of raising a TypeError.

rapidjson.MM_SORT_KEYS

Alphabetically order dictionary keys.

Exceptions

exception rapidjson.JSONDecodeError

A subclass of ValueError, raised when trying to parse an invalid JSON, either by Validator objects or by loads() function.

exception rapidjson.ValidationError

Exception raised by Validator objects, a subclass of ValueError.

Its args attribute is a tuple with three string values, respectively the schema keyword that generated the failure, its JSON pointer and a JSON pointer to the error location in the (invalid) document.

write_mode related constants

rapidjson.WM_COMPACT

The default dump mode, without any extra whitespace.

rapidjson.WM_PRETTY

This selects the RapidJSON PrettyWriter, to produce more readable JSON: each array’s item and object’s key will be preceded by a newline, and nested structures will be indented.

rapidjson.WM_SINGLE_LINE_ARRAY

This tells the PrettyWriter to emit arrays on a single line, instead of separating items with a newline.