# 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 enum import math import re from typing import ( Any, Callable, IO, Iterable, Mapping, Optional, Set, Tuple, Type, Union, ) import unicodedata from json5.parser import Parser # Used when encoding keys, below. _reserved_word_re: Optional[re.Pattern] = None 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: IO, *, 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. You can use `load(..., consume_trailing=False)` to repeatedly read values from a file. However, in the current implementation `load` does this by reading the entire file into memory before doing anything, so it is not very efficient. 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. """ 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: str, *, 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, ): """Deserialize ``s`` (a string containing a JSON5 document) to a Python object. Supports 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 string to start parsing at. 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: str, *, 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, ): """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, and (d) 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 = '1 2 3 4' >>> values = [] >>> start = 0 >>> while True: ... v, err, pos = json5.parse(s, start=start, consume_trailing=False) ... if v: ... 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 [1, 2, 3, 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: raise ValueError('Empty strings are not legal JSON5') start = start or 0 parser = Parser(s, '', 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 _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: return object_pairs_hook(pairs) if object_hook: return object_hook(dict(pairs)) return dict(pairs) parse_float = parse_float or float parse_int = parse_int or int parse_constant = parse_constant or _fp_constant_parser 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': if v.startswith('0x') or v.startswith('0X'): return parse_int(v, base=16) 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 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((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, *, 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, **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, **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, **kw, ): """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. *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, **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, **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 = default or _raise_type_error self.sort_keys = sort_keys self.quote_keys = quote_keys self.trailing_commas = trailing_commas self.allow_duplicate_keys = allow_duplicate_keys self.quote_style = quote_style 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 f{obj}') 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('Illegal JSON5 value: f{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) ): 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 < 128: encoded_ch = ch elif 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' if ch == '\v': return r'\v' if ch == '\0': return r'\0' 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) # Ideally we'd use collections.abc.Mapping and collections.abc.Sequence # here, but for backwards-compatibility with potential old callers, # we only check for the two attributes we need in each case. if hasattr(obj, 'keys') and hasattr(obj, '__getitem__'): s = self._encode_dict(obj, seen, level + 1) elif hasattr(obj, '__getitem__') and hasattr(obj, '__iter__'): s = self._encode_array(obj, seen, level + 1) else: s = self.encode(self.default(obj), seen, level + 1, 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: if not obj: return '{}' 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: if key_str in new_keys: raise ValueError(f'duplicate key {repr(key)}') new_keys.add(key_str) 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 s += end_str + '}' return s def _encode_array(self, obj: Any, seen: Set, level: int) -> str: if not obj: return '[]' indent_str, end_str = self._spacers(level) item_sep = self.item_separator + indent_str return ( '[' + indent_str + item_sep.join( self.encode(el, seen, level, as_key=False) for el in obj ) + 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 def _is_id_start(self, ch: str) -> bool: return unicodedata.category(ch) in ( 'Lu', 'Ll', 'Li', 'Lt', 'Lm', 'Lo', 'Nl', ) def _is_id_continue(self, ch: str) -> bool: return unicodedata.category(ch) in ( 'Lu', 'Ll', 'Li', 'Lt', 'Lm', 'Lo', 'Nl', 'Nd', 'Mn', 'Mc', 'Pc', ) def is_reserved_word(self, key: str) -> bool: """Returns whether the key is a reserved word. There should normally be no need to override this, unless there have been reserved words added in later versions of the JSON5 spec and this implementation has not yet been updated to handle the changes yet.""" global _reserved_word_re if _reserved_word_re is None: # List taken from section 7.6.1 of ECMA-262, version 5.1. # https://262.ecma-international.org/5.1/#sec-7.6.1. # This includes currently reserved words, words reserved # for future use (both as of 5.1), null, true, and false. _reserved_word_re = re.compile( '(' + '|'.join( [ 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'implements', 'import', 'in', 'instanceof', 'interface', 'let', 'new', 'null', 'package', 'private', 'protected', 'public', 'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield', ] ) + ')$' ) return _reserved_word_re.match(key) is not None def _raise_type_error(obj) -> Any: raise TypeError(f'{repr(obj)} is not JSON5 serializable')