# Exposed functions and symbols

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

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 `str`ings and `list`s): 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 `dict`s 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.