156 lines
4.5 KiB
Python
156 lines
4.5 KiB
Python
"""Canonical JSON, RFC 8785 (JSON Canonicalization Scheme).
|
|
|
|
Non-normative.
|
|
The normative rule is spec/01-conventions.md.
|
|
Most values serialize through the standard library's C encoder, which escapes strings exactly as RFC 8785 does.
|
|
Values it would write differently take the exact path below: floats, integers beyond 2^53, and member names
|
|
outside the Basic Multilingual Plane, which RFC 8785 sorts by UTF-16 code units rather than by code points.
|
|
"""
|
|
|
|
import json
|
|
import math
|
|
|
|
_C = json.JSONEncoder(ensure_ascii=False, separators=(",", ":"), sort_keys=True, allow_nan=False)
|
|
_EXACT_INT = 2**53
|
|
|
|
_ESC = {
|
|
0x08: "\\b",
|
|
0x09: "\\t",
|
|
0x0A: "\\n",
|
|
0x0C: "\\f",
|
|
0x0D: "\\r",
|
|
0x22: '\\"',
|
|
0x5C: "\\\\",
|
|
}
|
|
|
|
|
|
def _string(s):
|
|
out = ['"']
|
|
for ch in s:
|
|
cp = ord(ch)
|
|
if 0xD800 <= cp <= 0xDFFF:
|
|
raise ValueError("lone surrogate in string")
|
|
if cp in _ESC:
|
|
out.append(_ESC[cp])
|
|
elif cp < 0x20:
|
|
out.append("\\u%04x" % cp)
|
|
else:
|
|
out.append(ch)
|
|
out.append('"')
|
|
return "".join(out)
|
|
|
|
|
|
def _number(x):
|
|
"""ECMAScript Number.prototype.toString, as RFC 8785 requires."""
|
|
if isinstance(x, bool):
|
|
raise TypeError("bool is not a number")
|
|
if isinstance(x, int):
|
|
if abs(x) > 2**53:
|
|
raise ValueError("integer outside the IEEE 754 exact range")
|
|
return str(x)
|
|
if not math.isfinite(x):
|
|
raise ValueError("NaN and Infinity are not JSON")
|
|
if x == 0:
|
|
return "0"
|
|
if x < 0:
|
|
return "-" + _number(-x)
|
|
# Shortest round-trip digits, as ECMAScript requires.
|
|
r = repr(x)
|
|
if "e" in r or "E" in r:
|
|
mant, exp = r.lower().split("e")
|
|
exp = int(exp)
|
|
else:
|
|
mant, exp = r, 0
|
|
if "." in mant:
|
|
ip, fp = mant.split(".")
|
|
else:
|
|
ip, fp = mant, ""
|
|
digits = (ip + fp).lstrip("0")
|
|
# Position of the decimal point relative to the start of `digits`.
|
|
lead_zeros = len(ip + fp) - len((ip + fp).lstrip("0"))
|
|
n = len(ip) - lead_zeros + exp
|
|
digits = digits.rstrip("0") or "0"
|
|
k = len(digits)
|
|
if k <= n <= 21:
|
|
return digits + "0" * (n - k)
|
|
if 0 < n <= 21:
|
|
return digits[:n] + "." + digits[n:]
|
|
if -6 < n <= 0:
|
|
return "0." + "0" * (-n) + digits
|
|
e = n - 1
|
|
sign = "+" if e >= 0 else "-"
|
|
if k == 1:
|
|
return digits + "e" + sign + str(abs(e))
|
|
return digits[0] + "." + digits[1:] + "e" + sign + str(abs(e))
|
|
|
|
|
|
def _key(s):
|
|
# RFC 8785 sorts member names by their UTF-16 code units.
|
|
return s.encode("utf-16-be")
|
|
|
|
|
|
def _fast(v):
|
|
"""True when the C encoder writes `v` exactly as RFC 8785 does."""
|
|
t = type(v)
|
|
if t is str or v is None or t is bool:
|
|
return True
|
|
if t is int:
|
|
return -_EXACT_INT <= v <= _EXACT_INT
|
|
if t is dict:
|
|
for k, x in v.items():
|
|
if type(k) is not str or (not k.isascii() and max(k) > "\uffff") or not _fast(x):
|
|
return False
|
|
return True
|
|
if t is list or t is tuple:
|
|
return all(_fast(x) for x in v)
|
|
return False
|
|
|
|
|
|
def dumps(value):
|
|
"""Serialize `value` to canonical JSON text."""
|
|
if _fast(value):
|
|
text = _C.encode(value)
|
|
if not text.isascii():
|
|
try:
|
|
text.encode("utf-8")
|
|
except UnicodeEncodeError:
|
|
raise ValueError("lone surrogate in string") from None
|
|
return text
|
|
return _exact(value)
|
|
|
|
|
|
def _exact(value):
|
|
if value is None:
|
|
return "null"
|
|
if value is True:
|
|
return "true"
|
|
if value is False:
|
|
return "false"
|
|
if isinstance(value, str):
|
|
return _string(value)
|
|
if isinstance(value, (int, float)):
|
|
return _number(value)
|
|
if isinstance(value, (list, tuple)):
|
|
return "[" + ",".join(dumps(v) for v in value) + "]"
|
|
if isinstance(value, dict):
|
|
for k in value:
|
|
if not isinstance(k, str):
|
|
raise TypeError("object keys must be strings")
|
|
items = sorted(value.items(), key=lambda kv: _key(kv[0]))
|
|
return "{" + ",".join(_string(k) + ":" + dumps(v) for k, v in items) + "}"
|
|
raise TypeError("not JSON: %r" % type(value))
|
|
|
|
|
|
def dumpb(value):
|
|
"""Canonical JSON as UTF-8 bytes."""
|
|
return dumps(value).encode("utf-8")
|
|
|
|
|
|
def loads_line(data):
|
|
"""Parse one canonical JSON line of bytes, refusing a line that is not canonical."""
|
|
import json as _json
|
|
value = _json.loads(data.decode("utf-8"))
|
|
if dumpb(value) != data:
|
|
raise ValueError("not canonical JSON")
|
|
return value
|