mirror of
https://github.com/SickGear/SickGear.git
synced 2024-11-15 01:15:05 +00:00
Update SimpleJSON 3.18.1 (c891b95) → 3.19.1 (aeb63ee).
This commit is contained in:
JackDandy
parent
4da91221a9
commit
c0adcf5933
6 changed files with 132 additions and 129 deletions
|
|
@ -1,4 +1,9 @@
|
|||
### 3.28.0 (2023-04-12 13:05:00 UTC)
|
||||
### 3.29.0 (2023-xx-xx xx:xx:00 UTC)
|
||||
|
||||
* Update SimpleJSON 3.18.1 (c891b95) to 3.19.1 (aeb63ee)
|
||||
|
||||
|
||||
### 3.28.0 (2023-04-12 13:05:00 UTC)
|
||||
|
||||
* Update html5lib 1.1 (f87487a) to 1.2-dev (3e500bb)
|
||||
* Update package resource API 63.2.0 (3ae44cd) to 67.5.1 (f51eccd)
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ Serializing multiple objects to JSON lines (newline-delimited JSON)::
|
|||
|
||||
"""
|
||||
from __future__ import absolute_import
|
||||
__version__ = '3.18.1'
|
||||
__version__ = '3.19.1'
|
||||
__all__ = [
|
||||
'dump', 'dumps', 'load', 'loads',
|
||||
'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
|
||||
|
|
@ -149,28 +149,10 @@ def _import_c_make_encoder():
|
|||
except ImportError:
|
||||
return None
|
||||
|
||||
_default_encoder = JSONEncoder(
|
||||
skipkeys=False,
|
||||
ensure_ascii=True,
|
||||
check_circular=True,
|
||||
allow_nan=True,
|
||||
indent=None,
|
||||
separators=None,
|
||||
encoding='utf-8',
|
||||
default=None,
|
||||
use_decimal=True,
|
||||
namedtuple_as_object=True,
|
||||
tuple_as_array=True,
|
||||
iterable_as_array=False,
|
||||
bigint_as_string=False,
|
||||
item_sort_key=None,
|
||||
for_json=False,
|
||||
ignore_nan=False,
|
||||
int_as_string_bitcount=None,
|
||||
)
|
||||
_default_encoder = JSONEncoder()
|
||||
|
||||
def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
|
||||
allow_nan=True, cls=None, indent=None, separators=None,
|
||||
allow_nan=False, cls=None, indent=None, separators=None,
|
||||
encoding='utf-8', default=None, use_decimal=True,
|
||||
namedtuple_as_object=True, tuple_as_array=True,
|
||||
bigint_as_string=False, sort_keys=False, item_sort_key=None,
|
||||
|
|
@ -187,10 +169,10 @@ def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
|
|||
contain non-ASCII characters, so long as they do not need to be escaped
|
||||
by JSON. When it is true, all non-ASCII characters are escaped.
|
||||
|
||||
If *allow_nan* is false, then it will be a ``ValueError`` to
|
||||
serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
|
||||
in strict compliance of the original JSON specification, instead of using
|
||||
the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). See
|
||||
If *allow_nan* is true (default: ``False``), then out of range ``float``
|
||||
values (``nan``, ``inf``, ``-inf``) will be serialized to
|
||||
their JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``)
|
||||
instead of raising a ValueError. See
|
||||
*ignore_nan* for ECMA-262 compliant behavior.
|
||||
|
||||
If *indent* is a string, then JSON array elements and object members
|
||||
|
|
@ -258,7 +240,7 @@ def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
|
|||
"""
|
||||
# cached encoder
|
||||
if (not skipkeys and ensure_ascii and
|
||||
check_circular and allow_nan and
|
||||
check_circular and not allow_nan and
|
||||
cls is None and indent is None and separators is None and
|
||||
encoding == 'utf-8' and default is None and use_decimal
|
||||
and namedtuple_as_object and tuple_as_array and not iterable_as_array
|
||||
|
|
@ -292,7 +274,7 @@ def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
|
|||
|
||||
|
||||
def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
|
||||
allow_nan=True, cls=None, indent=None, separators=None,
|
||||
allow_nan=False, cls=None, indent=None, separators=None,
|
||||
encoding='utf-8', default=None, use_decimal=True,
|
||||
namedtuple_as_object=True, tuple_as_array=True,
|
||||
bigint_as_string=False, sort_keys=False, item_sort_key=None,
|
||||
|
|
@ -312,10 +294,11 @@ def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
|
|||
for container types will be skipped and a circular reference will
|
||||
result in an ``OverflowError`` (or worse).
|
||||
|
||||
If ``allow_nan`` is false, then it will be a ``ValueError`` to
|
||||
serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
|
||||
strict compliance of the JSON specification, instead of using the
|
||||
JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
|
||||
If *allow_nan* is true (default: ``False``), then out of range ``float``
|
||||
values (``nan``, ``inf``, ``-inf``) will be serialized to
|
||||
their JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``)
|
||||
instead of raising a ValueError. See
|
||||
*ignore_nan* for ECMA-262 compliant behavior.
|
||||
|
||||
If ``indent`` is a string, then JSON array elements and object members
|
||||
will be pretty-printed with a newline followed by that string repeated
|
||||
|
|
@ -383,7 +366,7 @@ def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
|
|||
"""
|
||||
# cached encoder
|
||||
if (not skipkeys and ensure_ascii and
|
||||
check_circular and allow_nan and
|
||||
check_circular and not allow_nan and
|
||||
cls is None and indent is None and separators is None and
|
||||
encoding == 'utf-8' and default is None and use_decimal
|
||||
and namedtuple_as_object and tuple_as_array and not iterable_as_array
|
||||
|
|
@ -412,14 +395,12 @@ def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
|
|||
**kw).encode(obj)
|
||||
|
||||
|
||||
_default_decoder = JSONDecoder(encoding=None, object_hook=None,
|
||||
object_pairs_hook=None)
|
||||
_default_decoder = JSONDecoder()
|
||||
|
||||
|
||||
def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
|
||||
parse_int=None, parse_constant=None, object_pairs_hook=None,
|
||||
use_decimal=False, namedtuple_as_object=True, tuple_as_array=True,
|
||||
**kw):
|
||||
use_decimal=False, allow_nan=False, **kw):
|
||||
"""Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
|
||||
a JSON document as `str` or `bytes`) to a Python object.
|
||||
|
||||
|
|
@ -442,23 +423,27 @@ def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
|
|||
takes priority.
|
||||
|
||||
*parse_float*, if specified, will be called with the string of every
|
||||
JSON float to be decoded. By default, this is equivalent to
|
||||
JSON float to be decoded. By default, this is equivalent to
|
||||
``float(num_str)``. This can be used to use another datatype or parser
|
||||
for JSON floats (e.g. :class:`decimal.Decimal`).
|
||||
|
||||
*parse_int*, if specified, will be called with the string of every
|
||||
JSON int to be decoded. By default, this is equivalent to
|
||||
JSON int to be decoded. By default, this is equivalent to
|
||||
``int(num_str)``. This can be used to use another datatype or parser
|
||||
for JSON integers (e.g. :class:`float`).
|
||||
|
||||
*parse_constant*, if specified, will be called with one of the
|
||||
following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This
|
||||
can be used to raise an exception if invalid JSON numbers are
|
||||
encountered.
|
||||
*allow_nan*, if True (default false), will allow the parser to
|
||||
accept the non-standard floats ``NaN``, ``Infinity``, and ``-Infinity``
|
||||
and enable the use of the deprecated *parse_constant*.
|
||||
|
||||
If *use_decimal* is true (default: ``False``) then it implies
|
||||
parse_float=decimal.Decimal for parity with ``dump``.
|
||||
|
||||
*parse_constant*, if specified, will be
|
||||
called with one of the following strings: ``'-Infinity'``,
|
||||
``'Infinity'``, ``'NaN'``. It is not recommended to use this feature,
|
||||
as it is rare to parse non-compliant JSON containing these values.
|
||||
|
||||
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
|
||||
kwarg. NOTE: You should use *object_hook* or *object_pairs_hook* instead
|
||||
of subclassing whenever possible.
|
||||
|
|
@ -468,12 +453,12 @@ def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
|
|||
encoding=encoding, cls=cls, object_hook=object_hook,
|
||||
parse_float=parse_float, parse_int=parse_int,
|
||||
parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,
|
||||
use_decimal=use_decimal, **kw)
|
||||
use_decimal=use_decimal, allow_nan=allow_nan, **kw)
|
||||
|
||||
|
||||
def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
|
||||
parse_int=None, parse_constant=None, object_pairs_hook=None,
|
||||
use_decimal=False, **kw):
|
||||
use_decimal=False, allow_nan=False, **kw):
|
||||
"""Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
|
||||
document) to a Python object.
|
||||
|
||||
|
|
@ -505,14 +490,18 @@ def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
|
|||
``int(num_str)``. This can be used to use another datatype or parser
|
||||
for JSON integers (e.g. :class:`float`).
|
||||
|
||||
*parse_constant*, if specified, will be called with one of the
|
||||
following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This
|
||||
can be used to raise an exception if invalid JSON numbers are
|
||||
encountered.
|
||||
*allow_nan*, if True (default false), will allow the parser to
|
||||
accept the non-standard floats ``NaN``, ``Infinity``, and ``-Infinity``
|
||||
and enable the use of the deprecated *parse_constant*.
|
||||
|
||||
If *use_decimal* is true (default: ``False``) then it implies
|
||||
parse_float=decimal.Decimal for parity with ``dump``.
|
||||
|
||||
*parse_constant*, if specified, will be
|
||||
called with one of the following strings: ``'-Infinity'``,
|
||||
``'Infinity'``, ``'NaN'``. It is not recommended to use this feature,
|
||||
as it is rare to parse non-compliant JSON containing these values.
|
||||
|
||||
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
|
||||
kwarg. NOTE: You should use *object_hook* or *object_pairs_hook* instead
|
||||
of subclassing whenever possible.
|
||||
|
|
@ -521,7 +510,7 @@ def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
|
|||
if (cls is None and encoding is None and object_hook is None and
|
||||
parse_int is None and parse_float is None and
|
||||
parse_constant is None and object_pairs_hook is None
|
||||
and not use_decimal and not kw):
|
||||
and not use_decimal and not allow_nan and not kw):
|
||||
return _default_decoder.decode(s)
|
||||
if cls is None:
|
||||
cls = JSONDecoder
|
||||
|
|
@ -539,6 +528,8 @@ def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
|
|||
if parse_float is not None:
|
||||
raise TypeError("use_decimal=True implies parse_float=Decimal")
|
||||
kw['parse_float'] = Decimal
|
||||
if allow_nan:
|
||||
kw['allow_nan'] = True
|
||||
return cls(encoding=encoding, **kw).decode(s)
|
||||
|
||||
|
||||
|
|
@ -560,22 +551,9 @@ def _toggle_speedups(enabled):
|
|||
scan.make_scanner = scan.py_make_scanner
|
||||
dec.make_scanner = scan.make_scanner
|
||||
global _default_decoder
|
||||
_default_decoder = JSONDecoder(
|
||||
encoding=None,
|
||||
object_hook=None,
|
||||
object_pairs_hook=None,
|
||||
)
|
||||
_default_decoder = JSONDecoder()
|
||||
global _default_encoder
|
||||
_default_encoder = JSONEncoder(
|
||||
skipkeys=False,
|
||||
ensure_ascii=True,
|
||||
check_circular=True,
|
||||
allow_nan=True,
|
||||
indent=None,
|
||||
separators=None,
|
||||
encoding='utf-8',
|
||||
default=None,
|
||||
)
|
||||
_default_encoder = JSONEncoder()
|
||||
|
||||
def simple_first(kv):
|
||||
"""Helper function to pass to item_sort_key to sort simple
|
||||
|
|
|
|||
|
|
@ -1843,7 +1843,7 @@ bail:
|
|||
}
|
||||
|
||||
static PyObject *
|
||||
_parse_constant(PyScannerObject *s, PyObject *constant, Py_ssize_t idx, Py_ssize_t *next_idx_ptr)
|
||||
_parse_constant(PyScannerObject *s, PyObject *pystr, PyObject *constant, Py_ssize_t idx, Py_ssize_t *next_idx_ptr)
|
||||
{
|
||||
/* Read a JSON constant from PyString pystr.
|
||||
constant is the Python string that was found
|
||||
|
|
@ -1855,6 +1855,10 @@ _parse_constant(PyScannerObject *s, PyObject *constant, Py_ssize_t idx, Py_ssize
|
|||
Returns the result of parse_constant
|
||||
*/
|
||||
PyObject *rval;
|
||||
if (s->parse_constant == Py_None) {
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, idx);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* rval = parse_constant(constant) */
|
||||
rval = PyObject_CallOneArg(s->parse_constant, constant);
|
||||
|
|
@ -1886,7 +1890,7 @@ _match_number_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssiz
|
|||
/* read a sign if it's there, make sure it's not the end of the string */
|
||||
if (str[idx] == '-') {
|
||||
if (idx >= end_idx) {
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, idx);
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, start);
|
||||
return NULL;
|
||||
}
|
||||
idx++;
|
||||
|
|
@ -1903,7 +1907,7 @@ _match_number_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssiz
|
|||
}
|
||||
/* no integer digits, error */
|
||||
else {
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, idx);
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, start);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -1949,8 +1953,10 @@ _match_number_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssiz
|
|||
/* rval = PyFloat_FromDouble(PyOS_ascii_atof(PyString_AS_STRING(numstr))); */
|
||||
double d = PyOS_string_to_double(PyString_AS_STRING(numstr),
|
||||
NULL, NULL);
|
||||
if (d == -1.0 && PyErr_Occurred())
|
||||
if (d == -1.0 && PyErr_Occurred()) {
|
||||
Py_DECREF(numstr);
|
||||
return NULL;
|
||||
}
|
||||
rval = PyFloat_FromDouble(d);
|
||||
}
|
||||
}
|
||||
|
|
@ -1993,7 +1999,7 @@ _match_number_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_
|
|||
/* read a sign if it's there, make sure it's not the end of the string */
|
||||
if (PyUnicode_READ(kind, str, idx) == '-') {
|
||||
if (idx >= end_idx) {
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, idx);
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, start);
|
||||
return NULL;
|
||||
}
|
||||
idx++;
|
||||
|
|
@ -2013,7 +2019,7 @@ _match_number_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_
|
|||
}
|
||||
else {
|
||||
/* no integer digits, error */
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, idx);
|
||||
raise_errmsg(ERR_EXPECTING_VALUE, pystr, start);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -2156,7 +2162,7 @@ scan_once_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *n
|
|||
case 'N':
|
||||
/* NaN */
|
||||
if ((idx + 2 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'N') {
|
||||
rval = _parse_constant(s, JSON_NaN, idx, next_idx_ptr);
|
||||
rval = _parse_constant(s, pystr, JSON_NaN, idx, next_idx_ptr);
|
||||
}
|
||||
else
|
||||
fallthrough = 1;
|
||||
|
|
@ -2164,7 +2170,7 @@ scan_once_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *n
|
|||
case 'I':
|
||||
/* Infinity */
|
||||
if ((idx + 7 < length) && str[idx + 1] == 'n' && str[idx + 2] == 'f' && str[idx + 3] == 'i' && str[idx + 4] == 'n' && str[idx + 5] == 'i' && str[idx + 6] == 't' && str[idx + 7] == 'y') {
|
||||
rval = _parse_constant(s, JSON_Infinity, idx, next_idx_ptr);
|
||||
rval = _parse_constant(s, pystr, JSON_Infinity, idx, next_idx_ptr);
|
||||
}
|
||||
else
|
||||
fallthrough = 1;
|
||||
|
|
@ -2172,7 +2178,7 @@ scan_once_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *n
|
|||
case '-':
|
||||
/* -Infinity */
|
||||
if ((idx + 8 < length) && str[idx + 1] == 'I' && str[idx + 2] == 'n' && str[idx + 3] == 'f' && str[idx + 4] == 'i' && str[idx + 5] == 'n' && str[idx + 6] == 'i' && str[idx + 7] == 't' && str[idx + 8] == 'y') {
|
||||
rval = _parse_constant(s, JSON_NegInfinity, idx, next_idx_ptr);
|
||||
rval = _parse_constant(s, pystr, JSON_NegInfinity, idx, next_idx_ptr);
|
||||
}
|
||||
else
|
||||
fallthrough = 1;
|
||||
|
|
@ -2275,7 +2281,7 @@ scan_once_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_
|
|||
if ((idx + 2 < length) &&
|
||||
PyUnicode_READ(kind, str, idx + 1) == 'a' &&
|
||||
PyUnicode_READ(kind, str, idx + 2) == 'N') {
|
||||
rval = _parse_constant(s, JSON_NaN, idx, next_idx_ptr);
|
||||
rval = _parse_constant(s, pystr, JSON_NaN, idx, next_idx_ptr);
|
||||
}
|
||||
else
|
||||
fallthrough = 1;
|
||||
|
|
@ -2290,7 +2296,7 @@ scan_once_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_
|
|||
PyUnicode_READ(kind, str, idx + 5) == 'i' &&
|
||||
PyUnicode_READ(kind, str, idx + 6) == 't' &&
|
||||
PyUnicode_READ(kind, str, idx + 7) == 'y') {
|
||||
rval = _parse_constant(s, JSON_Infinity, idx, next_idx_ptr);
|
||||
rval = _parse_constant(s, pystr, JSON_Infinity, idx, next_idx_ptr);
|
||||
}
|
||||
else
|
||||
fallthrough = 1;
|
||||
|
|
@ -2306,7 +2312,7 @@ scan_once_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_
|
|||
PyUnicode_READ(kind, str, idx + 6) == 'i' &&
|
||||
PyUnicode_READ(kind, str, idx + 7) == 't' &&
|
||||
PyUnicode_READ(kind, str, idx + 8) == 'y') {
|
||||
rval = _parse_constant(s, JSON_NegInfinity, idx, next_idx_ptr);
|
||||
rval = _parse_constant(s, pystr, JSON_NegInfinity, idx, next_idx_ptr);
|
||||
}
|
||||
else
|
||||
fallthrough = 1;
|
||||
|
|
|
|||
|
|
@ -46,9 +46,35 @@ BACKSLASH = {
|
|||
|
||||
DEFAULT_ENCODING = "utf-8"
|
||||
|
||||
if hasattr(sys, 'get_int_max_str_digits'):
|
||||
bounded_int = int
|
||||
else:
|
||||
def bounded_int(s, INT_MAX_STR_DIGITS=4300):
|
||||
"""Backport of the integer string length conversion limitation
|
||||
|
||||
https://docs.python.org/3/library/stdtypes.html#int-max-str-digits
|
||||
"""
|
||||
if len(s) > INT_MAX_STR_DIGITS:
|
||||
raise ValueError("Exceeds the limit (%s) for integer string conversion: value has %s digits" % (INT_MAX_STR_DIGITS, len(s)))
|
||||
return int(s)
|
||||
|
||||
|
||||
def scan_four_digit_hex(s, end, _m=re.compile(r'^[0-9a-fA-F]{4}$').match):
|
||||
"""Scan a four digit hex number from s[end:end + 4]
|
||||
"""
|
||||
msg = "Invalid \\uXXXX escape sequence"
|
||||
esc = s[end:end + 4]
|
||||
if not _m(esc):
|
||||
raise JSONDecodeError(msg, s, end - 2)
|
||||
try:
|
||||
return int(esc, 16), end + 4
|
||||
except ValueError:
|
||||
raise JSONDecodeError(msg, s, end - 2)
|
||||
|
||||
def py_scanstring(s, end, encoding=None, strict=True,
|
||||
_b=BACKSLASH, _m=STRINGCHUNK.match, _join=u''.join,
|
||||
_PY3=PY3, _maxunicode=sys.maxunicode):
|
||||
_PY3=PY3, _maxunicode=sys.maxunicode,
|
||||
_scan_four_digit_hex=scan_four_digit_hex):
|
||||
"""Scan the string s for a JSON string. End is the index of the
|
||||
character in s after the quote that started the JSON string.
|
||||
Unescapes all valid JSON string escape sequences and raises ValueError
|
||||
|
|
@ -67,6 +93,7 @@ def py_scanstring(s, end, encoding=None, strict=True,
|
|||
if chunk is None:
|
||||
raise JSONDecodeError(
|
||||
"Unterminated string starting at", s, begin)
|
||||
prev_end = end
|
||||
end = chunk.end()
|
||||
content, terminator = chunk.groups()
|
||||
# Content is contains zero or more unescaped string characters
|
||||
|
|
@ -81,7 +108,7 @@ def py_scanstring(s, end, encoding=None, strict=True,
|
|||
elif terminator != '\\':
|
||||
if strict:
|
||||
msg = "Invalid control character %r at"
|
||||
raise JSONDecodeError(msg, s, end)
|
||||
raise JSONDecodeError(msg, s, prev_end)
|
||||
else:
|
||||
_append(terminator)
|
||||
continue
|
||||
|
|
@ -100,35 +127,18 @@ def py_scanstring(s, end, encoding=None, strict=True,
|
|||
end += 1
|
||||
else:
|
||||
# Unicode escape sequence
|
||||
msg = "Invalid \\uXXXX escape sequence"
|
||||
esc = s[end + 1:end + 5]
|
||||
escX = esc[1:2]
|
||||
if len(esc) != 4 or escX == 'x' or escX == 'X':
|
||||
raise JSONDecodeError(msg, s, end - 1)
|
||||
try:
|
||||
uni = int(esc, 16)
|
||||
except ValueError:
|
||||
raise JSONDecodeError(msg, s, end - 1)
|
||||
if uni < 0 or uni > _maxunicode:
|
||||
raise JSONDecodeError(msg, s, end - 1)
|
||||
end += 5
|
||||
uni, end = _scan_four_digit_hex(s, end + 1)
|
||||
# Check for surrogate pair on UCS-4 systems
|
||||
# Note that this will join high/low surrogate pairs
|
||||
# but will also pass unpaired surrogates through
|
||||
if (_maxunicode > 65535 and
|
||||
uni & 0xfc00 == 0xd800 and
|
||||
s[end:end + 2] == '\\u'):
|
||||
esc2 = s[end + 2:end + 6]
|
||||
escX = esc2[1:2]
|
||||
if len(esc2) == 4 and not (escX == 'x' or escX == 'X'):
|
||||
try:
|
||||
uni2 = int(esc2, 16)
|
||||
except ValueError:
|
||||
raise JSONDecodeError(msg, s, end)
|
||||
if uni2 & 0xfc00 == 0xdc00:
|
||||
uni = 0x10000 + (((uni - 0xd800) << 10) |
|
||||
(uni2 - 0xdc00))
|
||||
end += 6
|
||||
uni2, end2 = _scan_four_digit_hex(s, end + 2)
|
||||
if uni2 & 0xfc00 == 0xdc00:
|
||||
uni = 0x10000 + (((uni - 0xd800) << 10) |
|
||||
(uni2 - 0xdc00))
|
||||
end = end2
|
||||
char = unichr(uni)
|
||||
# Append the unescaped character
|
||||
_append(char)
|
||||
|
|
@ -169,7 +179,7 @@ def JSONObject(state, encoding, strict, scan_once, object_hook,
|
|||
return pairs, end + 1
|
||||
elif nextchar != '"':
|
||||
raise JSONDecodeError(
|
||||
"Expecting property name enclosed in double quotes",
|
||||
"Expecting property name enclosed in double quotes or '}'",
|
||||
s, end)
|
||||
end += 1
|
||||
while True:
|
||||
|
|
@ -296,14 +306,15 @@ class JSONDecoder(object):
|
|||
| null | None |
|
||||
+---------------+-------------------+
|
||||
|
||||
It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
|
||||
When allow_nan=True, it also understands
|
||||
``NaN``, ``Infinity``, and ``-Infinity`` as
|
||||
their corresponding ``float`` values, which is outside the JSON spec.
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, encoding=None, object_hook=None, parse_float=None,
|
||||
parse_int=None, parse_constant=None, strict=True,
|
||||
object_pairs_hook=None):
|
||||
object_pairs_hook=None, allow_nan=False):
|
||||
"""
|
||||
*encoding* determines the encoding used to interpret any
|
||||
:class:`str` objects decoded by this instance (``'utf-8'`` by
|
||||
|
|
@ -336,10 +347,13 @@ class JSONDecoder(object):
|
|||
``int(num_str)``. This can be used to use another datatype or parser
|
||||
for JSON integers (e.g. :class:`float`).
|
||||
|
||||
*parse_constant*, if specified, will be called with one of the
|
||||
following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This
|
||||
can be used to raise an exception if invalid JSON numbers are
|
||||
encountered.
|
||||
*allow_nan*, if True (default false), will allow the parser to
|
||||
accept the non-standard floats ``NaN``, ``Infinity``, and ``-Infinity``.
|
||||
|
||||
*parse_constant*, if specified, will be
|
||||
called with one of the following strings: ``'-Infinity'``,
|
||||
``'Infinity'``, ``'NaN'``. It is not recommended to use this feature,
|
||||
as it is rare to parse non-compliant JSON containing these values.
|
||||
|
||||
*strict* controls the parser's behavior when it encounters an
|
||||
invalid control character in a string. The default setting of
|
||||
|
|
@ -353,8 +367,8 @@ class JSONDecoder(object):
|
|||
self.object_hook = object_hook
|
||||
self.object_pairs_hook = object_pairs_hook
|
||||
self.parse_float = parse_float or float
|
||||
self.parse_int = parse_int or int
|
||||
self.parse_constant = parse_constant or _CONSTANTS.__getitem__
|
||||
self.parse_int = parse_int or bounded_int
|
||||
self.parse_constant = parse_constant or (allow_nan and _CONSTANTS.__getitem__ or None)
|
||||
self.strict = strict
|
||||
self.parse_object = JSONObject
|
||||
self.parse_array = JSONArray
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ import re
|
|||
from operator import itemgetter
|
||||
# Do not import Decimal directly to avoid reload issues
|
||||
import decimal
|
||||
from .compat import unichr, binary_type, text_type, string_types, integer_types, PY3
|
||||
from .compat import binary_type, text_type, string_types, integer_types, PY3
|
||||
def _import_speedups():
|
||||
try:
|
||||
from . import _speedups
|
||||
|
|
@ -140,7 +140,7 @@ class JSONEncoder(object):
|
|||
key_separator = ': '
|
||||
|
||||
def __init__(self, skipkeys=False, ensure_ascii=True,
|
||||
check_circular=True, allow_nan=True, sort_keys=False,
|
||||
check_circular=True, allow_nan=False, sort_keys=False,
|
||||
indent=None, separators=None, encoding='utf-8', default=None,
|
||||
use_decimal=True, namedtuple_as_object=True,
|
||||
tuple_as_array=True, bigint_as_string=False,
|
||||
|
|
@ -161,10 +161,11 @@ class JSONEncoder(object):
|
|||
prevent an infinite recursion (which would cause an OverflowError).
|
||||
Otherwise, no such check takes place.
|
||||
|
||||
If allow_nan is true, then NaN, Infinity, and -Infinity will be
|
||||
encoded as such. This behavior is not JSON specification compliant,
|
||||
but is consistent with most JavaScript based encoders and decoders.
|
||||
Otherwise, it will be a ValueError to encode such floats.
|
||||
If allow_nan is true (default: False), then out of range float
|
||||
values (nan, inf, -inf) will be serialized to
|
||||
their JavaScript equivalents (NaN, Infinity, -Infinity)
|
||||
instead of raising a ValueError. See
|
||||
ignore_nan for ECMA-262 compliant behavior.
|
||||
|
||||
If sort_keys is true, then the output of dictionaries will be
|
||||
sorted by key; this is useful for regression tests to ensure
|
||||
|
|
@ -294,7 +295,7 @@ class JSONEncoder(object):
|
|||
# This doesn't pass the iterator directly to ''.join() because the
|
||||
# exceptions aren't as detailed. The list call should be roughly
|
||||
# equivalent to the PySequence_Fast that ''.join() would do.
|
||||
chunks = self.iterencode(o, _one_shot=True)
|
||||
chunks = self.iterencode(o)
|
||||
if not isinstance(chunks, (list, tuple)):
|
||||
chunks = list(chunks)
|
||||
if self.ensure_ascii:
|
||||
|
|
@ -302,7 +303,7 @@ class JSONEncoder(object):
|
|||
else:
|
||||
return u''.join(chunks)
|
||||
|
||||
def iterencode(self, o, _one_shot=False):
|
||||
def iterencode(self, o):
|
||||
"""Encode the given object and yield each string
|
||||
representation as available.
|
||||
|
||||
|
|
@ -356,8 +357,7 @@ class JSONEncoder(object):
|
|||
key_memo = {}
|
||||
int_as_string_bitcount = (
|
||||
53 if self.bigint_as_string else self.int_as_string_bitcount)
|
||||
if (_one_shot and c_make_encoder is not None
|
||||
and self.indent is None):
|
||||
if (c_make_encoder is not None and self.indent is None):
|
||||
_iterencode = c_make_encoder(
|
||||
markers, self.default, _encoder, self.indent,
|
||||
self.key_separator, self.item_separator, self.sort_keys,
|
||||
|
|
@ -370,7 +370,7 @@ class JSONEncoder(object):
|
|||
_iterencode = _make_iterencode(
|
||||
markers, self.default, _encoder, self.indent, floatstr,
|
||||
self.key_separator, self.item_separator, self.sort_keys,
|
||||
self.skipkeys, _one_shot, self.use_decimal,
|
||||
self.skipkeys, self.use_decimal,
|
||||
self.namedtuple_as_object, self.tuple_as_array,
|
||||
int_as_string_bitcount,
|
||||
self.item_sort_key, self.encoding, self.for_json,
|
||||
|
|
@ -398,14 +398,14 @@ class JSONEncoderForHTML(JSONEncoder):
|
|||
def encode(self, o):
|
||||
# Override JSONEncoder.encode because it has hacks for
|
||||
# performance that make things more complicated.
|
||||
chunks = self.iterencode(o, True)
|
||||
chunks = self.iterencode(o)
|
||||
if self.ensure_ascii:
|
||||
return ''.join(chunks)
|
||||
else:
|
||||
return u''.join(chunks)
|
||||
|
||||
def iterencode(self, o, _one_shot=False):
|
||||
chunks = super(JSONEncoderForHTML, self).iterencode(o, _one_shot)
|
||||
def iterencode(self, o):
|
||||
chunks = super(JSONEncoderForHTML, self).iterencode(o)
|
||||
for chunk in chunks:
|
||||
chunk = chunk.replace('&', '\\u0026')
|
||||
chunk = chunk.replace('<', '\\u003c')
|
||||
|
|
@ -419,7 +419,7 @@ class JSONEncoderForHTML(JSONEncoder):
|
|||
|
||||
|
||||
def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
|
||||
_key_separator, _item_separator, _sort_keys, _skipkeys, _one_shot,
|
||||
_key_separator, _item_separator, _sort_keys, _skipkeys,
|
||||
_use_decimal, _namedtuple_as_object, _tuple_as_array,
|
||||
_int_as_string_bitcount, _item_sort_key,
|
||||
_encoding,_for_json,
|
||||
|
|
|
|||
|
|
@ -60,11 +60,11 @@ def py_make_scanner(context):
|
|||
else:
|
||||
res = parse_int(integer)
|
||||
return res, m.end()
|
||||
elif nextchar == 'N' and string[idx:idx + 3] == 'NaN':
|
||||
elif parse_constant and nextchar == 'N' and string[idx:idx + 3] == 'NaN':
|
||||
return parse_constant('NaN'), idx + 3
|
||||
elif nextchar == 'I' and string[idx:idx + 8] == 'Infinity':
|
||||
elif parse_constant and nextchar == 'I' and string[idx:idx + 8] == 'Infinity':
|
||||
return parse_constant('Infinity'), idx + 8
|
||||
elif nextchar == '-' and string[idx:idx + 9] == '-Infinity':
|
||||
elif parse_constant and nextchar == '-' and string[idx:idx + 9] == '-Infinity':
|
||||
return parse_constant('-Infinity'), idx + 9
|
||||
else:
|
||||
raise JSONDecodeError(errmsg, string, idx)
|
||||
|
|
|
|||
Loading…
Reference in a new issue