# Copyright 2015 Google Inc. All rights reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

import builtins

import enum

import math

import re

import unicodedata

from typing import (

IO,

Any,

Callable,

Iterable,

Mapping,

Optional,

Set,

Tuple,

Type,

Union,

)

from json5.parser import Parser

# Used when encoding keys, below.

_reserved_word_re: Optional[re.Pattern] = None

def _get_mapping_types():

frozendict_type = getattr(builtins, 'frozendict', None)

return (dict,) if frozendict_type is None else (dict, frozendict_type)

_mapping_types = _get_mapping_types()

# A high surrogate (U+D800..U+DBFF) immediately followed by a low surrogate

# (U+DC00..U+DFFF). `\u` escapes decode one UTF-16 code unit each, so an

# astral character written as a surrogate pair arrives here as two separate

# code points that have to be recombined.

_surrogate_pair_re = re.compile('[\ud800-\udbff][\udc00-\udfff]')

def _join_surrogate_pairs(s: str) -> str:

"""Combine any UTF-16 surrogate pairs in a decoded string into the single

code point they represent, matching the `json` module and ECMAScript

string semantics. Lone surrogates are left untouched."""

if _surrogate_pair_re.search(s) is None:

return s

def combine(m: re.Match) -> str:

hi, lo = ord(m.group()[0]), ord(m.group()[1])

return chr(0x10000 + ((hi - 0xD800) << 10) + (lo - 0xDC00))

return _surrogate_pair_re.sub(combine, s)

class QuoteStyle(enum.Enum):

"""Controls how strings will be quoted during encoding.

By default, for compatibility with the `json` module and older versions of

`json5`, strings (not being used as keys and that are legal identifiers)

will always be double-quoted, and any double quotes in the string will be

escaped. This is `QuoteStyle.ALWAYS_DOUBLE`. If you pass

`QuoteStyle.ALWAYS_SINGLE`, then strings will always be single-quoted, and

any single quotes in the string will be escaped. If you pass

`QuoteStyle.PREFER_DOUBLE`, then the behavior is the same as ALWAYS_DOUBLE

and strings will be double-quoted *unless* the string contains more double

quotes than single quotes, in which case the string will be single-quoted

and single quotes will be escaped. If you pass `QuoteStyle.PREFER_SINGLE`,

then the behavior is the same as ALWAYS_SINGLE and strings will be

single-quoted *unless* the string contains more single quotes than double

quotes, in which case the string will be double-quoted and any double

quotes will be escaped.

*Note:* PREFER_DOUBLE and PREFER_SINGLE can impact performance, since in

order to know which encoding to use you have to iterate over the entire

string to count the number of single and double quotes. The codes guesses

at an encoding while doing so, but if it guess wrong, the entire string has

to be re-encoded, which will slow things down. If you are very concerned

about performance (a) you probably shouldn't be using this library in the

first place, because it just isn't very fast, and (b) you should use

ALWAYS_DOUBLE or ALWAYS_SINGLE, which won't have this issue.

"""

ALWAYS_DOUBLE = 'always_double'

ALWAYS_SINGLE = 'always_single'

PREFER_DOUBLE = 'prefer_double'

PREFER_SINGLE = 'prefer_single'

def load(

fp: Union[IO[str], IO[bytes]],

*,

encoding: Optional[str] = None,

cls: Any = None,

object_hook: Optional[Callable[[Mapping[str, Any]], Any]] = None,

parse_float: Optional[Callable[[str], Any]] = None,

parse_int: Optional[Callable[[str], Any]] = None,

parse_constant: Optional[Callable[[str], Any]] = None,

strict: bool = True,

object_pairs_hook: Optional[

Callable[[Iterable[Tuple[str, Any]]], Any]

] = None,

allow_duplicate_keys: bool = True,

consume_trailing: bool = True,

start: Optional[int] = None,

) -> Any:

"""Deserialize ``fp`` (a ``.read()``-supporting file-like object

containing a JSON document) to a Python object.

Supports almost the same arguments as ``json.load()`` except that:

- the `cls` keyword is ignored.

- an extra `allow_duplicate_keys` parameter supports checking for

duplicate keys in a object; by default, this is True for

compatibility with ``json.load()``, but if set to False and

the object contains duplicate keys, a ValueError will be raised.

- an extra `consume_trailing` parameter specifies whether to

consume any trailing characters after a valid object has been

parsed. By default, this value is True and the only legal

trailing characters are whitespace. If this value is set to False,

parsing will stop when a valid object has been parsed and any

trailing characters in the string will be ignored.

- an extra `start` parameter specifies the zero-based offset into the

file to start parsing at. If `start` is None, parsing will

start at the current position in the file, and line number

and column values will be reported as if starting from the

beginning of the file; If `start` is not None,

`load` will seek to zero and then read (and discard) the

appropriate number of characters before beginning parsing;

the file must be seekable for this to work correctly.

- the `parse_int` parameter does not have the same semantics as

in the `json` module: a custom callback is passed the integer

string as written, and must be able to handle both decimal and

hexadecimal literals (e.g. `0x1F`); only the default parser

decodes hexadecimal literals automatically.

- the `parse_constant` parameter does not have the same semantics

as in the `json` module either: a custom callback is passed the

constant's spelling as written, so in addition to `NaN`,

`Infinity` and `-Infinity` it must also accept the `-NaN` form

of negative NaN, which is legal JSON5.

`load()` reads the entire remaining stream into memory, even when

`consume_trailing=False`. That option controls whether the parser

validates trailing characters; it does not leave the stream positioned

after the parsed value. Repeated calls cannot read successive values

from a stream this way.

To read multiple values, read the input into a string once and call

`parse(..., consume_trailing=False)` repeatedly, passing each returned

position as the next `start`. See the example in `parse()`. These are

decoded-character positions, not byte offsets or file seek positions.

Raises

- `ValueError` if given an invalid document. This is different

from the `json` module, which raises `json.JSONDecodeError`.

- `UnicodeDecodeError` if given a byte string that is not a

legal UTF-8 document (or the equivalent, if using a different

`encoding`). This matches the `json` module.

"""

if start is not None:

fp.seek(0)

s = fp.read()

val, err, _ = parse(

s,

encoding=encoding,

cls=cls,

object_hook=object_hook,

parse_float=parse_float,

parse_int=parse_int,

parse_constant=parse_constant,

strict=strict,

object_pairs_hook=object_pairs_hook,

allow_duplicate_keys=allow_duplicate_keys,

consume_trailing=consume_trailing,

start=start,

)

if err:

raise ValueError(err)

return val

def loads(

s: Union[str, bytes],

*,

encoding: Optional[str] = None,

cls: Any = None,

object_hook: Optional[Callable[[Mapping[str, Any]], Any]] = None,

parse_float: Optional[Callable[[str], Any]] = None,

parse_int: Optional[Callable[[str], Any]] = None,

parse_constant: Optional[Callable[[str], Any]] = None,

strict: bool = True,

object_pairs_hook: Optional[

Callable[[Iterable[Tuple[str, Any]]], Any]

] = None,

allow_duplicate_keys: bool = True,

consume_trailing: bool = True,

start: Optional[int] = None,

) -> Any:

"""Deserialize ``s`` (a string containing a JSON5 document) to a Python

object.

Supports the same arguments as ``json.loads()`` except that:

- the `cls` keyword is ignored.

- an extra `allow_duplicate_keys` parameter supports checking for

duplicate keys in a object; by default, this is True for

compatibility with ``json.load()``, but if set to False and

the object contains duplicate keys, a ValueError will be raised.

- an extra `consume_trailing` parameter specifies whether to

consume any trailing characters after a valid object has been

parsed. By default, this value is True and the only legal

trailing characters are whitespace. If this value is set to False,

parsing will stop when a valid object has been parsed and any

trailing characters in the string will be ignored.

- an extra `start` parameter specifies the zero-based offset into the

string to start parsing at.

- the `parse_int` parameter does not have the same semantics as

in the `json` module: a custom callback is passed the integer

string as written, and must be able to handle both decimal and

hexadecimal literals (e.g. `0x1F`); only the default parser

decodes hexadecimal literals automatically.

- the `parse_constant` parameter does not have the same semantics

as in the `json` module either: a custom callback is passed the

constant's spelling as written, so in addition to `NaN`,

`Infinity` and `-Infinity` it must also accept the `-NaN` form

of negative NaN, which is legal JSON5.

Raises

- `ValueError` if given an invalid document. This is different

from the `json` module, which raises `json.JSONDecodeError`.

- `UnicodeDecodeError` if given a byte string that is not a

legal UTF-8 document (or the equivalent, if using a different

`encoding`). This matches the `json` module.

"""

val, err, _ = parse(

s=s,

encoding=encoding,

cls=cls,

object_hook=object_hook,

parse_float=parse_float,

parse_int=parse_int,

parse_constant=parse_constant,

strict=strict,

object_pairs_hook=object_pairs_hook,

allow_duplicate_keys=allow_duplicate_keys,

consume_trailing=consume_trailing,

start=start,

)

if err:

raise ValueError(err)

return val

def parse(

s: Union[str, bytes],

*,

encoding: Optional[str] = None,

cls: Any = None,

object_hook: Optional[Callable[[Mapping[str, Any]], Any]] = None,

parse_float: Optional[Callable[[str], Any]] = None,

parse_int: Optional[Callable[[str], Any]] = None,

parse_constant: Optional[Callable[[str], Any]] = None,

strict: bool = True,

object_pairs_hook: Optional[

Callable[[Iterable[Tuple[str, Any]]], Any]

] = None,

allow_duplicate_keys: bool = True,

consume_trailing: bool = True,

start: Optional[int] = None,

) -> Union[Tuple[Any, None, int], Tuple[None, str, int]]:

"""Parse ```s``, returning positional information along with a value.

This works exactly like `loads()`, except that (a) it returns the

position in the string where the parsing stopped (either due to

hitting an error or parsing a valid value) and any error as a string,

(b) it takes an optional `consume_trailing` parameter that says whether

to keep parsing the string after a valid value has been parsed; if True

(the default), any trailing characters must be whitespace. If False,

parsing stops when a valid value has been reached, (c) it takes an

optional `start` parameter that specifies a zero-based offset to start

parsing from in the string, (d) the `parse_int` parameter does not have

the same semantics as in the `json` module (see `loads()` for details),

(e) the `parse_constant` parameter also differs from the `json` module

(see `loads()` for details), and (f) the return value is different,

as described below.

`parse()` is useful if you have a string that might contain multiple

values and you need to extract all of them; you can do so by repeatedly

calling `parse`, setting `start` to the value returned in `position`

from the previous call.

Returns a tuple of (value, error_string, position). If the string

was a legal value, `value` will be the deserialized value,

`error_string` will be `None`, and `position` will be one

past the zero-based offset where the parser stopped reading.

If the string was not a legal value,

`value` will be `None`, `error_string` will be the string value

of the exception that would've been raised, and `position` will

be the zero-based farthest offset into the string where the parser

hit an error.

Raises:

- `UnicodeDecodeError` if given a byte string that is not a

legal UTF-8 document (or the equivalent, if using a different

`encoding`). This matches the `json` module.

Note that this does *not* raise a `ValueError`; instead any error is

returned as the second value in the tuple.

You can use this method to read in a series of values from a string

`s` as follows:

>>> import json5

>>> s = '0 false null 4'

>>> values = []

>>> start = 0

>>> while True:

... v, err, pos = json5.parse(s, start=start, consume_trailing=False)

... if err is None:

... values.append(v)

... start = pos

... if start == len(s) or s[start:].isspace():

... # Reached the end of the string (ignoring trailing

... # whitespace

... break

... continue

... raise ValueError(err)

>>> values

[0, False, None, 4]

"""

assert cls is None, 'Custom decoders are not supported'

if isinstance(s, bytes):

encoding = encoding or 'utf-8'

s = s.decode(encoding)

if not s:

return None, 'Empty strings are not legal JSON5', 0

start = start or 0

parser = Parser(s, '<string>', pos=start)

ast, err, pos = parser.parse(

global_vars={'_strict': strict, '_consume_trailing': consume_trailing}

)

if err:

return None, err, pos

try:

value = _convert(

ast,

object_hook=object_hook,

parse_float=parse_float,

parse_int=parse_int,

parse_constant=parse_constant,

object_pairs_hook=object_pairs_hook,

allow_duplicate_keys=allow_duplicate_keys,

)

return value, None, pos

except ValueError as e:

return None, str(e), pos

def _convert(

ast,

object_hook,

parse_float,

parse_int,

parse_constant,

object_pairs_hook,

allow_duplicate_keys,

):

def _fp_constant_parser(s):

return float(s.replace('Infinity', 'inf').replace('NaN', 'nan'))

def _parse_int(s):

if s.lstrip('+-').startswith(('0x', '0X')):

return int(s, 16)

return int(s)

def _dictify(pairs):

if not allow_duplicate_keys:

keys = set()

for key, _ in pairs:

if key in keys:

raise ValueError(f'Duplicate key "{key}" found in object')

keys.add(key)

if object_pairs_hook is not None:

return object_pairs_hook(pairs)

if object_hook is not None:

return object_hook(dict(pairs))

return dict(pairs)

parse_float = float if parse_float is None else parse_float

parse_int = _parse_int if parse_int is None else parse_int

parse_constant = (

_fp_constant_parser if parse_constant is None else parse_constant

)

return _walk_ast(ast, _dictify, parse_float, parse_int, parse_constant)

def _walk_ast(

el,

dictify: Callable[[Iterable[Tuple[str, Any]]], Any],

parse_float,

parse_int,

parse_constant,

):

if el == 'None':

return None

if el == 'True':

return True

if el == 'False':

return False

ty, v = el

if ty == 'number':

unsigned = v[1:] if v[:1] in ('-', '+') else v

if unsigned.startswith(('0x', '0X')):

return parse_int(v)

if '.' in v or 'e' in v or 'E' in v:

return parse_float(v)

if 'Infinity' in v or 'NaN' in v:

return parse_constant(v)

return parse_int(v)

if ty == 'string':

return _join_surrogate_pairs(v)

if ty == 'object':

pairs = []

for key, val_expr in v:

val = _walk_ast(

val_expr, dictify, parse_float, parse_int, parse_constant

)

pairs.append((_join_surrogate_pairs(key), val))

return dictify(pairs)

if ty == 'array':

return [

_walk_ast(el, dictify, parse_float, parse_int, parse_constant)

for el in v

]

raise ValueError('unknown el: ' + el) # pragma: no cover

def dump(

obj: Any,

fp: IO[str],

*,

skipkeys: bool = False,

ensure_ascii: bool = True,

check_circular: bool = True,

allow_nan: bool = True,

cls: Optional[Type['JSON5Encoder']] = None,

indent: Optional[Union[int, str]] = None,

separators: Optional[Tuple[str, str]] = None,

default: Optional[Callable[[Any], Any]] = None,

sort_keys: bool = False,

quote_keys: bool = False,

trailing_commas: bool = True,

allow_duplicate_keys: bool = True,

quote_style: QuoteStyle = QuoteStyle.ALWAYS_DOUBLE,

use_duck_typing: bool = False,

**kw,

):

"""Serialize ``obj`` to a JSON5-formatted stream to ``fp``,

a ``.write()``-supporting file-like object.

Supports the same arguments as ``dumps()``, below.

Calling ``dump(obj, fp, quote_keys=True, trailing_commas=False, \

allow_duplicate_keys=True)``

should produce exactly the same output as ``json.dump(obj, fp).``

"""

fp.write(

dumps(

obj=obj,

skipkeys=skipkeys,

ensure_ascii=ensure_ascii,

check_circular=check_circular,

allow_nan=allow_nan,

cls=cls,

indent=indent,

separators=separators,

default=default,

sort_keys=sort_keys,

quote_keys=quote_keys,

trailing_commas=trailing_commas,

allow_duplicate_keys=allow_duplicate_keys,

quote_style=quote_style,

use_duck_typing=use_duck_typing,

**kw,

)

)

def dumps(

obj: Any,

*,

skipkeys: bool = False,

ensure_ascii: bool = True,

check_circular: bool = True,

allow_nan: bool = True,

cls: Optional[Type['JSON5Encoder']] = None,

indent: Optional[Union[int, str]] = None,

separators: Optional[Tuple[str, str]] = None,

default: Optional[Callable[[Any], Any]] = None,

sort_keys: bool = False,

quote_keys: bool = False,

trailing_commas: bool = True,

allow_duplicate_keys: bool = True,

quote_style: QuoteStyle = QuoteStyle.ALWAYS_DOUBLE,

use_duck_typing: bool = False,

**kw: Any,

):

"""Serialize ``obj`` to a JSON5-formatted string.

Supports the same arguments as ``json.dumps()``, except that:

- The ``encoding`` keyword is ignored; Unicode strings are always written.

- By default, object keys that are legal identifiers are not quoted; if you

pass ``quote_keys=True``, they will be.

- By default, if lists and objects span multiple lines of output (i.e.,

when ``indent`` >=0), the last item will have a trailing comma after it.

If you pass ``trailing_commas=False``, it will not.

- If you use a number, a boolean, or ``None`` as a key value in a dict, it

will be converted to the corresponding JSON string value, e.g. "1",

"true", or "null". By default, ``dump()`` will match the `json` modules

behavior and produce malformed JSON if you mix keys of different types

that have the same converted value; e.g., ``{1: "foo", "1": "bar"}``

produces '{"1": "foo", "1": "bar"}', an object with duplicated keys. If

you pass ``allow_duplicate_keys=False``, an exception will be raised

instead.

- If `quote_keys` is true, then keys of objects will be enclosed in quotes,

as in regular JSON. Otheriwse, keys will not be enclosed in quotes unless

they contain whitespace.

- If `trailing_commas` is false, then commas will not be inserted after the

final elements of objects and arrays, as in regular JSON. Otherwise,

such commas will be inserted.

- If `allow_duplicate_keys` is false, then only the last entry with a given

key will be written. Otherwise, all entries with the same key will be

written.

- `quote_style` controls how strings are encoded. See the documentation

for the `QuoteStyle` class, above, for how this is used.

- If `use_duck_typing` is true, objects with `keys` and `__getitem__`

methods are encoded as objects, and objects with `__getitem__` and

`__iter__` methods are encoded as arrays. Otherwise, only `dict`

instances are encoded as objects and `list` or `tuple` instances are

encoded as arrays, matching the standard `json` module. On Python 3.15

and later, the built-in `frozendict` is also encoded as an object.

*Note*: Strings that are being used as unquoted keys are not affected

by this parameter and remain unquoted.

*`quote_style` was added in version 0.10.0*.

Other keyword arguments are allowed and will be passed to the

encoder so custom encoders can get them, but otherwise they will

be ignored in an attempt to provide some amount of forward-compatibility.

*Note:* the standard JSON module explicitly calls `int.__repr(obj)__`

and `float.__repr(obj)__` to encode ints and floats, thereby bypassing

any custom representations you might have for objects that are subclasses

of ints and floats, and, for compatibility, JSON5 does the same thing.

To override this behavior, create a subclass of JSON5Encoder

that overrides `encode()` and handles your custom representation.

For example:

```

>>> import json5

>>> from typing import Any, Set

>>>

>>> class Hex(int):

... def __repr__(self):

... return hex(self)

>>>

>>> class CustomEncoder(json5.JSON5Encoder):

... def encode(

... self, obj: Any, seen: Set, level: int, *, as_key: bool

... ) -> str:

... if isinstance(obj, Hex):

... return repr(obj)

... return super().encode(obj, seen, level, as_key=as_key)

...

>>> json5.dumps([20, Hex(20)], cls=CustomEncoder)

'[20, 0x14]'

```

*Note:* calling ``dumps(obj, quote_keys=True, trailing_commas=False, \

allow_duplicate_keys=True)``

should produce exactly the same output as ``json.dumps(obj).``

"""

cls = cls or JSON5Encoder

enc = cls(

skipkeys=skipkeys,

ensure_ascii=ensure_ascii,

check_circular=check_circular,

allow_nan=allow_nan,

indent=indent,

separators=separators,

default=default,

sort_keys=sort_keys,

quote_keys=quote_keys,

trailing_commas=trailing_commas,

allow_duplicate_keys=allow_duplicate_keys,

quote_style=quote_style,

use_duck_typing=use_duck_typing,

**kw,

)

return enc.encode(obj, seen=set(), level=0, as_key=False)

class JSON5Encoder:

def __init__(

self,

*,

skipkeys: bool = False,

ensure_ascii: bool = True,

check_circular: bool = True,

allow_nan: bool = True,

indent: Optional[Union[int, str]] = None,

separators: Optional[Tuple[str, str]] = None,

default: Optional[Callable[[Any], Any]] = None,

sort_keys: bool = False,

quote_keys: bool = False,

trailing_commas: bool = True,

allow_duplicate_keys: bool = True,

quote_style: QuoteStyle = QuoteStyle.ALWAYS_DOUBLE,

use_duck_typing: bool = False,

**kw,

):

"""Provides a class that may be overridden to customize the behavior

of `dumps()`. The keyword args are the same as for that function.

*Added in version 0.10.0"""

# Ignore unrecognized keyword arguments in the hope of providing

# some level of backwards- and forwards-compatibility.

del kw

self.skipkeys = skipkeys

self.ensure_ascii = ensure_ascii

self.check_circular = check_circular

self.allow_nan = allow_nan

self.indent = indent

self.separators = separators

if separators is None:

separators = (', ', ': ') if indent is None else (',', ': ')

self.item_separator, self.kv_separator = separators

self.default_fn = _raise_type_error if default is None else default

self.sort_keys = sort_keys

self.quote_keys = quote_keys

self.trailing_commas = trailing_commas

self.allow_duplicate_keys = allow_duplicate_keys

if not isinstance(quote_style, QuoteStyle):

raise TypeError(

'quote_style argument must be a json5.QuoteStyle value'

)

self.quote_style = quote_style

self.use_duck_typing = use_duck_typing

def default(self, obj: Any) -> Any:

"""Provides a last-ditch option to encode a value that the encoder

doesn't otherwise recognize, by converting `obj` to a value that

*can* (and will) be serialized by the other methods in the class.

Note: this must not return a serialized value (i.e., string)

directly, as that'll result in a doubly-encoded value."""

return self.default_fn(obj)

def encode(

self,

obj: Any,

seen: Set,

level: int,

*,

as_key: bool,

) -> str:

"""Returns an JSON5-encoded version of an arbitrary object. This can

be used to provide customized serialization of objects. Overridden

methods of this class should handle their custom objects and then

fall back to super.encode() if they've been passed a normal object.

`seen` is used for duplicate object tracking when `check_circular`

is True.

`level` represents the current indentation level, which increases

by one for each recursive invocation of encode (i.e., whenever

we're encoding the values of a dict or a list).

May raise `TypeError` if the object is the wrong type to be

encoded (i.e., your custom routine can't handle it either), and

`ValueError` if there's something wrong with the value, e.g.

a float value of NaN when `allow_nan` is false.

If `as_key` is true, the return value should be a double-quoted string

representation of the object, unless obj is a string that can be an

identifier (and quote_keys is false and obj isn't a reserved word).

If the object should not be used as a key, `TypeError` should be

raised; that allows the base implementation to implement `skipkeys`

properly.

"""

seen = seen or set()

s = self._encode_basic_type(obj, as_key=as_key)

if s is not None:

return s

if as_key:

raise TypeError(f'Invalid key: {obj!r}')

return self._encode_non_basic_type(obj, seen, level)

def _encode_basic_type(self, obj: Any, *, as_key: bool) -> Optional[str]:

"""Returns None if the object is not a basic type."""

if isinstance(obj, str):

return self._encode_str(obj, as_key=as_key)

# Check for True/False before ints because True and False are

# also considered ints and so would be represented as 1 and 0

# if we did ints first.

if obj is True:

return '"true"' if as_key else 'true'

if obj is False:

return '"false"' if as_key else 'false'

if obj is None:

return '"null"' if as_key else 'null'

if isinstance(obj, int):

return self._encode_int(obj, as_key=as_key)

if isinstance(obj, float):

return self._encode_float(obj, as_key=as_key)

return None

def _encode_int(self, obj: int, *, as_key: bool) -> str:

s = int.__repr__(obj)

return f'"{s}"' if as_key else s

def _encode_float(self, obj: float, *, as_key: bool) -> str:

if obj == float('inf'):

allowed = self.allow_nan

s = 'Infinity'

elif obj == float('-inf'):

allowed = self.allow_nan

s = '-Infinity'

elif math.isnan(obj):

allowed = self.allow_nan

s = 'NaN'

else:

allowed = True

s = float.__repr__(obj)

if not allowed:

raise ValueError(f'Illegal JSON5 value: {obj}')

return f'"{s}"' if as_key else s

def _encode_str(self, obj: str, *, as_key: bool) -> str:

if (

as_key

and self.is_identifier(obj)

and not self.quote_keys

and not self.is_reserved_word(obj)

and not (self.ensure_ascii and any(ord(ch) > 0xFFFF for ch in obj))

):

if self.ensure_ascii:

return ''.join(

self._escape_ch(ch) if ord(ch) > 127 else ch for ch in obj

)

return obj

return self._encode_quoted_str(obj, self.quote_style)

def _encode_quoted_str(self, obj: str, quote_style: QuoteStyle) -> str:

"""Returns a quoted string with a minimal number of escaped quotes."""

ret = []

double_quotes_seen = 0

single_quotes_seen = 0

sq = "'"

dq = '"'

for ch in obj:

if ch == dq:

# At first we will guess at which quotes to escape. If

# we guess wrong, we reencode the string below.

double_quotes_seen += 1

if quote_style in (

QuoteStyle.ALWAYS_DOUBLE,

QuoteStyle.PREFER_DOUBLE,

):

encoded_ch = self._escape_ch(dq)

else:

encoded_ch = dq

elif ch == sq:

single_quotes_seen += 1

if quote_style in (

QuoteStyle.ALWAYS_SINGLE,

QuoteStyle.PREFER_SINGLE,

):

encoded_ch = self._escape_ch(sq)

else:

encoded_ch = sq

elif ch == '\\':

encoded_ch = self._escape_ch(ch)

else:

o = ord(ch)

if o < 32:

encoded_ch = self._escape_ch(ch)

elif o < 127 or (

not self.ensure_ascii and ch not in ('\u2028', '\u2029')

):

encoded_ch = ch

else:

encoded_ch = self._escape_ch(ch)

ret.append(encoded_ch)

# We may have guessed wrong and need to reencode the string.

if (

double_quotes_seen > single_quotes_seen

and quote_style == QuoteStyle.PREFER_DOUBLE

):

return self._encode_quoted_str(obj, QuoteStyle.ALWAYS_SINGLE)

if (

single_quotes_seen > double_quotes_seen

and quote_style == QuoteStyle.PREFER_SINGLE

):

return self._encode_quoted_str(obj, QuoteStyle.ALWAYS_DOUBLE)

if quote_style in (QuoteStyle.ALWAYS_DOUBLE, QuoteStyle.PREFER_DOUBLE):

return '"' + ''.join(ret) + '"'

return "'" + ''.join(ret) + "'"

def _escape_ch(self, ch: str) -> str:

"""Returns the backslash-escaped representation of the char."""

if ch == '\\':

return '\\\\'

if ch == "'":

return r'\''

if ch == '"':

return r'\"'

if ch == '\n':

return r'\n'

if ch == '\r':

return r'\r'

if ch == '\t':

return r'\t'

if ch == '\b':

return r'\b'

if ch == '\f':

return r'\f'

o = ord(ch)

if o < 65536:

return rf'\u{o:04x}'

val = o - 0x10000

high = 0xD800 + (val >> 10)

low = 0xDC00 + (val & 0x3FF)

return rf'\u{high:04x}\u{low:04x}'

def _encode_non_basic_type(self, obj, seen: Set, level: int) -> str:

# Basic types can't be recursive so we only check for circularity

# on non-basic types. If for some reason the caller was using a

# subclass of a basic type and wanted to check circularity on it,

# it'd have to do so directly in a subclass of JSON5Encoder.

if self.check_circular:

i = id(obj)

if i in seen:

raise ValueError('Circular reference detected.')

seen.add(i)

is_mapping = isinstance(obj, _mapping_types) or (

self.use_duck_typing

and hasattr(obj, 'keys')

and hasattr(obj, '__getitem__')

)

is_array = isinstance(obj, (list, tuple)) or (

self.use_duck_typing

and hasattr(obj, '__getitem__')

and hasattr(obj, '__iter__')

)

if is_mapping:

s = self._encode_dict(obj, seen, level + 1)

elif is_array:

s = self._encode_array(obj, seen, level + 1)

else:

s = self.encode(self.default(obj), seen, level, as_key=False)

assert s is not None

if self.check_circular:

seen.remove(i)

return s

def _encode_dict(self, obj: Any, seen: set, level: int) -> str:

indent_str, end_str = self._spacers(level)

item_sep = self.item_separator + indent_str

kv_sep = self.kv_separator

if self.sort_keys:

keys = sorted(obj.keys())

else:

keys = obj.keys()

s = '{' + indent_str

first_key = True

new_keys = set()

for key in keys:

try:

key_str = self.encode(key, seen, level, as_key=True)

except TypeError:

if self.skipkeys:

continue

raise

if not self.allow_duplicate_keys:

# Compare the keys as they will be decoded, not as encoded:

# e.g. 1 and '1' are written as "1" and '1' with single

# quotes, and float('inf') and 'Infinity' are written as

# "Infinity" and Infinity, but each pair reads back as the

# same key. Non-string keys are always encoded as a plain

# double-quoted string.

key_name = key if isinstance(key, str) else key_str[1:-1]

if key_name in new_keys:

raise ValueError(f'duplicate key {key!r}')

new_keys.add(key_name)

if first_key:

first_key = False

else:

s += item_sep

val_str = self.encode(obj[key], seen, level, as_key=False)

s += key_str + kv_sep + val_str

if first_key:

return '{}'

s += end_str + '}'

return s

def _encode_array(self, obj: Any, seen: Set, level: int) -> str:

items = [self.encode(el, seen, level, as_key=False) for el in obj]

if not items:

return '[]'

indent_str, end_str = self._spacers(level)

item_sep = self.item_separator + indent_str

return '[' + indent_str + item_sep.join(items) + end_str + ']'

def _spacers(self, level: int) -> Tuple[str, str]:

if self.indent is not None:

end_str = ''

if self.trailing_commas:

end_str = ','

if isinstance(self.indent, int):

if self.indent > 0:

indent_str = '\n' + ' ' * self.indent * level

end_str += '\n' + ' ' * self.indent * (level - 1)

else:

indent_str = '\n'

end_str += '\n'

else:

indent_str = '\n' + self.indent * level

end_str += '\n' + self.indent * (level - 1)

else:

indent_str = ''

end_str = ''

return indent_str, end_str

def is_identifier(self, key: str) -> bool:

"""Returns whether the string could be used as a legal

EcmaScript/JavaScript identifier.

There should normally be no reason to override this, unless

the definition of identifiers change in later versions of the

JSON5 spec and this implementation hasn't been updated to handle

the changes yet."""

if (

not key

or not self._is_id_start(key[0])

and key[0] not in ('$', '_')

):

return False

for ch in key[1:]:

if not self._is_id_continue(ch) and ch not in ('$', '_'):

return False

return True