ݝ id
F d Z dZdZdZdZdZdZddlmZ e d g d
e ZeecZ
Z dd l Z e j Z
e
j e
j cZZd
ZdZ G d de Z e Zdd lZefdZ ee \ ZZZ d Z G d de Z e Z e Z [ d Z! e! \ a"a#a$[! G d de% Z&dedZ'dedZ(dfdZ)dfdZ*d Z+dd l,Z, G d d e,jZ Z.d Z/ G d d!e Z0 G d" d#e Z1 G d$ d%e Z2 G d& d'e3 Z4 G d( d)e4 Z5 G d* d+e4 Z6 G d, d-e4 Z7 G d. d/e4 Z8 G d0 d1e8 Z9 G d2 d3e9 Z: G d4 d5e8 Z; G d6 d7e; Z< G d8 d9e Z= G d: d;e Z> G d< d=e Z?d>Z@d?ZAd@ZBdAZCd?ZDdBZEdCZFdDZGdEZHdEZIdFZJdGZKdHZLdIZM G dJ dKeN ZOdLZPdMZQdNZRdOZSdPZTePdQeQdReRdSeSdTeTdUiZUdVeSiZVdW ZWddXlXmYZZ ddYlm[Z\ G dZ d[eeO\ Z] G d] d^e Z^dgd_a_dgd`a`dhdaZadgdbZb G dc dde Zcy # e$ r e
d e
d cZZY w xY w)ia A JSON data encoder and decoder.
This Python module implements the JSON (http://json.org/) data
encoding format; a subset of ECMAScript (aka JavaScript) for encoding
primitive data types (numbers, strings, booleans, lists, and
associative arrays) in a language-neutral simple text-based syntax.
It can encode or decode between JSON formatted strings and native
Python data types. Normally you would use the encode() and decode()
functions defined by this module, but if you want more control over
the processing you can use the JSON class.
This implementation tries to be as completely cormforming to all
intricacies of the standards as possible. It can operate in strict
mode (which only allows JSON-compliant syntax) or a non-strict mode
(which allows much more of the whole ECMAScript permitted syntax).
This includes complete support for Unicode strings (including
surrogate-pairs for non-BMP characters), and all number formats
including negative zero and IEEE 754 non-numbers such a NaN or
Infinity.
The JSON/ECMAScript to Python type mappings are:
---JSON--- ---Python---
null None
undefined undefined (note 1)
Boolean (true,false) bool (True or False)
Integer int or long (note 2)
Float float
String str or unicode ( "..." or u"..." )
Array [a, ...] list ( [...] )
Object {a:b, ...} dict ( {...} )
-- Note 1. an 'undefined' object is declared in this module which
represents the native Python value for this type when in
non-strict mode.
-- Note 2. some ECMAScript integers may be up-converted to Python
floats, such as 1e+40. Also integer -0 is converted to
float -0, so as to preserve the sign (which ECMAScript requires).
-- Note 3. numbers requiring more significant digits than can be
represented by the Python float type will be converted into a
Python Decimal type, from the standard 'decimal' module.
In addition, when operating in non-strict mode, several IEEE 754
non-numbers are also handled, and are mapped to specific Python
objects declared in this module:
NaN (not a number) nan (float('nan'))
Infinity, +Infinity inf (float('inf'))
-Infinity neginf (float('-inf'))
When encoding Python objects into JSON, you may use types other than
native lists or dictionaries, as long as they support the minimal
interfaces required of all sequences or mappings. This means you can
use generators and iterators, tuples, UserDict subclasses, etc.
To make it easier to produce JSON encoded representations of user
defined classes, if the object has a method named json_equivalent(),
then it will call that method and attempt to encode the object
returned from it instead. It will do this recursively as needed and
before any attempt to encode the object using it's default
strategies. Note that any json_equivalent() method should return
"equivalent" Python objects to be encoded, not an already-encoded
JSON-formatted string. There is no such aid provided to decode
JSON back into user-defined classes as that would dramatically
complicate the interface.
When decoding strings with this module it may operate in either
strict or non-strict mode. The strict mode only allows syntax which
is conforming to RFC 7159 (JSON), while the non-strict allows much
more of the permissible ECMAScript syntax.
The following are permitted when processing in NON-STRICT mode:
* Unicode format control characters are allowed anywhere in the input.
* All Unicode line terminator characters are recognized.
* All Unicode white space characters are recognized.
* The 'undefined' keyword is recognized.
* Hexadecimal number literals are recognized (e.g., 0xA6, 0177).
* String literals may use either single or double quote marks.
* Strings may contain \x (hexadecimal) escape sequences, as well as the
\v and \0 escape sequences.
* Lists may have omitted (elided) elements, e.g., [,,,,,], with
missing elements interpreted as 'undefined' values.
* Object properties (dictionary keys) can be of any of the
types: string literals, numbers, or identifiers (the later of
which are treated as if they are string literals)---as permitted
by ECMAScript. JSON only permits strings literals as keys.
Concerning non-strict and non-ECMAScript allowances:
* Octal numbers: If you allow the 'octal_numbers' behavior (which
is never enabled by default), then you can use octal integers
and octal character escape sequences (per the ECMAScript
standard Annex B.1.2). This behavior is allowed, if enabled,
because it was valid JavaScript at one time.
* Multi-line string literals: Strings which are more than one
line long (contain embedded raw newline characters) are never
permitted. This is neither valid JSON nor ECMAScript. Some other
JSON implementations may allow this, but this module considers
that behavior to be a mistake.
References:
* JSON (JavaScript Object Notation)
* RFC 7159. The application/json Media Type for JavaScript Object Notation (JSON)
* ECMA-262 3rd edition (1999)
* IEEE 754-1985: Standard for Binary Floating-Point Arithmetic.
u8 Deron Meranda , Niels Mündlerz$http://nielstron.github.io/demjson3/z
2021-09-08z3.0.5) ul Copyright (c) 2006-2021 Deron E. Meranda , Niels Mündler
Licensed under GNU LGPL (GNU Lesser General Public License) version 3.0
or later. See LICENSE.txt included with this software.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see
or .
r )
namedtuple version_info)majorminormicroN zapplication/jsonjsonc e Zd ZdZd Zd Zy)_dummy_context_managerz5A context manager that does nothing on entry or exit.c y N selfs F/var/www/html/eduruby.in/venv/lib/python3.12/site-packages/demjson3.py __enter__z _dummy_context_manager.__enter__ s c yNFr )r exc_typeexc_valexc_tbs r __exit__z _dummy_context_manager.__exit__ r N)__name__
__module__ __qualname____doc__r r r r r r
r
s ?
r r
c t t j t j f}| t j k( rt j
} t
| t j r%| j }t j | }d }n | t k( r | }t }d }n t d |5 |d }d}d} |dz }dd |z z } ||d
z } d D ] }
|||
z } | |z | |z k( s|} n |rn=d d |dz
z z } d d |d
z
z z }
d\ }}dD ] }d}d} | dz |z t | z }|
dz |z t | z } || |z } || |z }|r)t | d j r
|| s|k( rn|}|dz }s |dz |k( r |dk( r|}n|}||k r |dk( rd}nd}||z d
z } | dz |z t | z }|
dz |z t | z } || |z } || |z }|r t | d j sd}n || s||k( rd} |s|}n|} ddd t dg d S # |$ r d}Y w xY w# |$ r d}Y @w xY w# 1 sw Y ;xY w)ab Determines the precision and range of the given float type.
The passed in 'number_type' argument should refer to the type of
floating-point number. It should either be the built-in 'float',
or decimal context or constructor; i.e., one of:
# 1. FLOAT TYPE
determine_float_limits( float )
# 2. DEFAULT DECIMAL CONTEXT
determine_float_limits( decimal.Decimal )
# 3. CUSTOM DECIMAL CONTEXT
ctx = decimal.Context( prec=75 )
determine_float_limits( ctx )
Returns a named tuple with components:
( significant_digits,
max_exponent,
min_exponent )
Where:
* significant_digits -- maximum number of *decimal* digits
that can be represented without any loss of precision.
This is conservative, so if there are 16 1/2 digits, it
will return 16, not 17.
* max_exponent -- The maximum exponent (power of 10) that can
be represented before an overflow (or rounding to
infinity) occurs.
* min_exponent -- The minimum exponent (negative power of 10)
that can be represented before either an underflow
(rounding to zero) or a subnormal result (loss of
precision) occurs. Note this is conservative, as
subnormal numbers are excluded.
c F | j xs | j S r )is_zero is_subnormalns r z(determine_float_limits.. s )H8H r c | dk( S Nr r r% s r r' z(determine_float_limits.. s
a r z5Expected a float type, e.g., float or decimal context0.0Nr r
z0.10 123456789z1. NN)+-
er0 float_limits)significant_digits max_exponent min_exponent)
ValueErrordecimalOverflow UnderflowDecimalDefaultContext
isinstanceContextcreate_decimal localcontextfloatr
TypeErrorstrisdigit _namedtuple) number_typenumeric_exceptions
create_num decimal_ctxis_zero_or_subnormalzero sigdigitsr& pfxasfxbbasebase0minexpmaxexpexpsignminvmaxvss0ff0ms r determine_float_limitsr^ s0 P %g&6&68I8IJgoo% ,, +w/ //
**;7 H
, / OPP Q %
AAq.C39%A"
sSy)H!d(+ !I
cY]++si!m,,#! 6 GDD s
W,s4y8A w.T:B"1
,A#B $.B q6!9,,.+A.Bw D "9D# ( !8t# #~!%!%D[ #~!%!%D[Q& ! s
W,s1v5A w.Q7B"1
,A#B $.B CF1I$5$5$7 -a0AG D D= 16 7Q f ;N & " "] * A B * A MQ Q s\ *AI.,/I. >IA I.;>I!9:I.I I. I I.!I+(I.*I++I..I7c P t t } | j | j fS r )r^ rB r5 r6 )vs r determine_float_precisionra _ s! u%A
!.. 11r c & e Zd ZdZg Zd Zd Zd Zy)_undefined_classz,Represents the ECMAScript 'undefined' value.c | j dz S )Nz
.undefined)r r s r __repr__z_undefined_class.__repr__q s --r c y)N undefinedr r s r __str__z_undefined_class.__str__t s r c yr r r s r __bool__z_undefined_class.__bool__w r r N)r r r r __slots__re rh rj r r r rc rc l s 6I.r rc c t d } t d }t d }| ||fS # t $ r t d } t d }t d }n# t $ r ddl}ddl}t t
j
d j }t t
j
d
j }t t
j
d j }|j d k( r@|j d
| d } |j d
| d }|j d
| d }nQ|j d
|ddd d } |j d
|ddd d }|j d
|ddd d }| }|dk7 r t d nT# t t f$ rB t j d } t j d }t j d }Y nw xY wY nw xY wY w xY w)ag Try to return the Nan, Infinity, and -Infinity float values.
This is necessarily complex because there is no standard
platform-independent way to do this in Python as the language
(opposed to some implementation of it) doesn't discuss
non-numbers. We try various strategies from the best to the
worst.
If this Python interpreter uses the IEEE 754 floating point
standard then the returned values will probably be real instances
of the 'float' type. Otherwise a custom class object is returned
which will attempt to simulate the correct behavior as much as
possible.
naninf-infNaNQINFz-INFr N7ff80000000000007ff0000000000000bdc145651592979dbigdgeEz+Unpacking raw IEEE 754 floats does not workNaNInfinity -Infinity)
rB r8 structsysbytes bytearrayfromhexdecode byteorderunpackrC r9 r< ) rm rn neginfr{ r| xnanxinfxcheckchecks r _nonnumber_float_constantsr s *6 ElElv L V K $6# 6-C,C6]F 6
6 # %%&89@@B Y . ./A B I I KL %%&89@@B
==E) --T215C --T215C "MM#v 6q 9E --T$B$Z8;C --T$B$Z8;C "MM#vdd| G?c 8 e Zd ZdZ fdZed Zd Z xZS )json_inta8 A subclass of the Python int/long that remembers its format (hex,octal,etc).
Initialize it the same as an int, but also accepts an additional keyword
argument 'number_format' which should be one of the NUMBER_FORMAT_* values.
n = json_int( x[, base, number_format=NUMBER_FORMAT_DECIMAL] )
c d|v r0|d }|d= |t t t t t fvrt d t }t
t | " | g|i |}||_ |S )N
number_formatz4json_int(): Invalid value for number_format argument)
NUMBER_FORMAT_DECIMALNUMBER_FORMAT_HEXNUMBER_FORMAT_OCTALNUMBER_FORMAT_LEGACYOCTALNUMBER_FORMAT_BINARYrC superr __new___jsonfmt)clsargskwargsr obj __class__s r r zjson_int.__new__ ss f $ "? 3M' %!#)$ % VWW 1MHc*3@@@$
r c | j S )z'The original radix format of the number)r r s r r zjson_int.number_format s }} r c | j }|t k( r t | d S |t k( r t | d S |t k( r t | d S |t
k( r| dk( ry| dk rd| z S d| z S t
| S )z5Returns the integer value formatted as a JSON literalz#xz#oz#br r, z-0%oz0%o)r r formatr r r rD )r fmts r json_formatzjson_int.json_format s mm # #$% %
'
'$% %
(
($% %
-
-qy $'' t|#t9 r ) r r r r r propertyr r
__classcell__r s @r r r s& $ r r c f |}t j }||k r| | |vr|dz
}||k r| | |vr|S )Nr
helpersunsafe_string_chars)rY startendiunsafes r skipstringsafer
sL
A
(
(F
c'ad&(
Q c'ad&(
Hr c |}| t | }||k r0| | }|dk( s|dk( s|dk( st | dk r |S |dz
}||k r0|S )N"'\ r
)lenord)rY r r r cs r skipstringsafe_slowr se
A
{!f
c'
aD 8qCx19A$ H
Q c'
Hr c |s| j | y t | D ], \ }}|dkD r| j | | j | . y r) )extend enumerateappend)orig_seq
extension_seqsepcharr xs r extend_list_with_sepr # sH
& m, DAq1u( OOA r c | t | D ]. \ }}|dkD r|r| j | | j | 0 y r) r r r r r separatorr parts r extend_and_flatten_list_with_sepr - s; ]+ 4 q5Y OOI & r c t | S )zYTakes a list of byte values (numbers) and returns a bytes (Python 3) or string (Python 2)r} byte_lists r _make_raw_bytesr 9 s
r c e Zd ZdZ eg d Z eg d Zed Zed d Z ed
d Z
ed
d Z edd Z edd
Z
edd Zy)utf32a Unicode UTF-32 and UCS4 encoding/decoding support.
This is for older Pythons whch did not have UTF-32 codecs.
JSON requires that all JSON implementations must support the
UTF-32 encoding (as well as UTF-8 and UTF-16). But earlier
versions of Python did not provide a UTF-32 codec, so we must
implement UTF-32 ourselves in case we need it.
See http://en.wikipedia.org/wiki/UTF-32
)r r )r r r r c d}| j } | dv r6t j t j t j
d }|S | dv r6t j t j t j d }|S | dv r4t j t j t j d }|S ) zA standard Python codec lookup function for UCS4/UTF32.
If if recognizes an encoding name it returns a CodecInfo
structure which contains the various encode and decoder
functions to use.
N)UCS4BEzUCS-4BEzUCS-4-BEUTF32BEzUTF-32BEz UTF-32-BEutf-32be)name)UCS4LEzUCS-4LEzUCS-4-LEUTF32LEzUTF-32LEz UTF-32-LEutf-32le)UCS4zUCS-4UTF32zUTF-32zutf-32)
uppercodecs CodecInfor utf32be_encodeutf32be_decodeutf32le_encodeutf32le_decodeencoder )r cis r lookupz utf32.lookupR s zz|
!!$$e&:&:B
!!$$e&:&:B
9
9!!%,, 8LB r Nc H ddl }ddl}t j }fd}|s |j }|j d dv rd}n&|j d dv rd}nt
d|z |j } |rd nd
}
d} |r4|r |t j n |t j | d z
} t | D ]R \ } }
t |
}d |cxk rd
k r#n n |dk( rn|dk( rd}nt d| | | d z d | | |
| | d z
} T | | fS )a% Encodes a Unicode string into a UTF-32 encoded byte string.
Returns a tuple: (bytearray, num_chars)
The errors argument should be one of 'strict', 'ignore', or 'replace'.
The endianness should be one of:
* 'B', '>', or 'big' -- Big endian
* 'L', '<', or 'little' -- Little endien
* None -- Default, from sys.byteorder
If include_bom is true a Byte-Order Mark will be written to
the beginning of the string, otherwise it will be omitted.
r Nc t S r r )r[ s r tobytesz utf32.encode..tobytes s 8Or zB>TzLL>%,, - N**+E
^^E . .
/ N**+E !NE % ]] 0 0 21 5
+
#A ,,.J *">(S!U,T
X
"q ($eSX/V
%,4$
uc#h* 5Aa!a%.Cx%a(A NI:~&A"7"7X%, aQ0Ka0O y(LLV- 116z '1$ . '1$ .!$ , U+, 22!QD.C!$ , U+, W 0 0 345 56 **r c 2 t j | |d S )zEDecodes a UTF-32LE (little endian) byte string into a Unicode string.r r r r r r r s r r zutf32.utf32le_decode ||C3|??r c 2 t j | |d S )zBDecodes a UTF-32BE (big endian) byte string into a Unicode string.r r r r s r r zutf32.utf32be_decode$ r r )r NT)r F)r N)r )r r r r r r r staticmethodr r r r r r r r r r r r A s ##56L"#56L" "H C& C&J Y Y Y Y U+ U+n @ @ @ @r r c dd l } g }t d D cg c]
}t | c}D ]1 }|dk( s|dk( s| j | dv s!|j | 3 dj | S c c}w )Nr r r CcCfZlZpr ) unicodedatar r
categoryr r )r! r r r s r _make_unsafe_string_charsr# / sm
F #El
+c!f
+ 8qDyK$8$8$;?W$W MM! 776? ,s A.c " e Zd ZdZdZdZ e ZddlZej Z dZ
e g d Z e
d Ze
d Ze
d
Ze
d Ze
d Ze
d
Ze
d Ze
d Ze
d Ze
d Ze
d Ze
d$d Ze
d Ze
d Ze
d Z e
d%d Z e
d Z e
d Z e
d Z e
d Z!e
d Z"e
d Z#e
d Z$e
d Z%e
d Z&e
d! Z'e
d" Z(e
d# Z)y)&r zA set of utility functions.0123456789ABCDEFabcdef01234567r NF)-breakcasecatchclassconstcontinuedebuggerdefaultdeletedoelseexportextendsfinallyforfunctionifimportin
instanceofletnewreturnr switchthisthrowtrytypeofvarvoidwhilewithyieldenum
implements interfacepackageprivate protectedpublicstaticnulltruefalsec t | S )z`Constructs a byte array (bytes in Python 3, str in Python 2) from a list of byte values (0-255).)r r s r make_raw_byteszhelpers.make_raw_bytes} s y))r c & | t j v S )zODetermines if the given character is a valid hexadecimal digit (0-9, a-f, A-F).)r hexdigitsr s r is_hex_digitzhelpers.is_hex_digit s G%%%%r c & | t j v S )z?Determines if the given character is a valid octal digit (0-7).)r octaldigitsrW s r is_octal_digitzhelpers.is_octal_digit s G''''r c | dk( xs | dk( S )zCDetermines if the given character is a valid binary digit (0 or 1).r, r+ r rW s r is_binary_digitzhelpers.is_binary_digit s Cx#18#r c
| dv S )zADetermines if the given character is a JSON white-space character
r rW s r char_is_json_wszhelpers.char_is_json_ws s I~ r c | dk\ rS| t j kD r@t j | \ }}|
t | }|S t | t | z }|S t | }|S )z@Just like Python's unichr() but works in narrow-Unicode Pythons. )r r make_surrogate_pairr
) codepointw1w2r s r r zhelpers.safe_unichr sm I0B0B$B 00;FBzG
Gc"g% IAr c r t | t s t | } | dv ryddl}|j | dk( S )z>Determines if the given character is a Unicode space character
Tr NZs)r> rD r! r" )r r! s r char_is_unicode_wszhelpers.char_is_unicode_ws s; !S!AA
##A&$..r c
| dv S )z:Determines if the given character is a JSON line separatorz
r rW s r char_is_json_eolzhelpers.char_is_json_eol s F{r c
| dv S )zDetermines if the given character is a Unicode line or
paragraph separator. These correspond to CR and LF as well as
Unicode characters in the Zl or Zp categories.
u
r rW s r char_is_unicode_eolzhelpers.char_is_unicode_eol s &&&r c . | j xs | dv S )zcDetermines if the character may be the first character of a
JavaScript identifier.
_$)isalpharW s r char_is_identifier_leaderz!helpers.char_is_identifier_leader s
yy{'a4i'r c . | j xs | dv S )zTDetermines if the character may be part of a JavaScript
identifier.
u _$isalnumrW s r char_is_identifier_tailz helpers.char_is_identifier_tail s
yy{3a#3 33r c | t | D ]. \ }}|dkD r|r| j | | j | 0 y r) r r s r r z(helpers.extend_and_flatten_list_with_sep s; / "GAt1u * OOD ! "r c ddl }| D cg c]" }|j t | dk7 s!|$ }}t |t sdj | }|S c c}w )a Filters out all Unicode format control characters from the string.
ECMAScript permits any Unicode "format control characters" to
appear at any place in the source code. They are to be
ignored as if they are not there before any other lexical
tokenization occurs. Note that JSON does not allow them,
except within string literals.
* Ref. ECMAScript section 7.1.
* http://en.wikipedia.org/wiki/Unicode_control_characters
There are dozens of Format Control Characters, for example:
U+00AD SOFT HYPHEN
U+200B ZERO WIDTH SPACE
U+2060 WORD JOINER
r Nr r )r! r" rD r> r )txtr! r txt2s r strip_format_control_charsz"helpers.strip_format_control_chars sT & Ga+"6"6s1v">$"FGG
$$774=D Hs
"AAc v ddl }t | |j r| S | j } ddl }t j
r.t j | }|s |j | }|S |S |j | }|S # t $ r d}Y |S w xY w# t $ r t j | }Y |S w xY w)zuWrapper around codecs.lookup().
Returns None if codec not found, rather than raising a LookupError.
r N) r r> r lowerr always_use_custom_codecsr r LookupError)encodingr cdks r lookup_codeczhelpers.lookup_codec s h 0 0 1O>># + +,,x(C '&--1C
s
-#fmmH-
# C
-ll8,
-s$ B 0B BB B87B8c : | rt | dk( ryg }t dt t | d D ]3 }| | }t |t r t | }|j
| 5 ddl}d\ }}}t | dk\ r| dd }t | dk\ r| dd }t | dk\ r| dd }d\ }} }
} } t | d k\ r|d }t | dk\ r|d } t | dk\ r|d }
t | dk\ r|d } | d
} t | t r t | } |r7t |d r||j k( s|t j k( r d }
| dd } |
S |r7t |d
r||j k( s|t j k( r d}
| dd } |
S |r||j k( r d}
| dd } |
S |r||j k( r d}
| dd } |
S |r||j k( r d}
| dd } |
S t | dk\ r|dk( r| dk( r|
dk( r | dk7 rd}
|
S t | dk\ r |dk7 r| dk( r|
dk( r| dk( r | dk( rd }
|
S t | dk\ r|dk( r | dk7 rd}
|
S t | dk\ r|dk7 r| dk( r | dk( rd}
|
S t d |cxk rdk rd}
|
S t d t d )zTakes a string (or byte array) and tries to determine the Unicode encoding it is in.
Returns the encoding name, as a string.
r utf-8r NNNNr. r )NNNNNr
rw r r r r zutf-16lezutf-16be utf8z6Can not determine the Unicode encoding for byte stream)r r minr> rD r r r hasattrr r r BOM_UTF16_LE BOM_UTF16_BEBOM_UTF8r8 )rY ordsr r r bom2bom3bom4rO rQ r rv zr s r auto_detect_encodingz helpers.auto_detect_encoding
s$ CFaK q#c!fa.) A!A!S!F KKN +dD q6Q;Ra5D q6Q;Ra5D q6Q;Ra5D 5
1aA q6Q;QA q6Q;QA q6Q;QA q6Q;QA
bE a AA
V^
,9L9L1L***!H!"AP O
V^
,9L9L1L***!H!"AD C df 1 11!H!"A> = df 1 11!H!"A8 7 dfoo- H!"A2 #
FaKAFqAv!q&Q!V!H
FaKAFqAv!q&Q!VQ!H Vq[Q!VQ!H Vq[Q!VQ16!H
Y!
"s
" H
# UV V* UV Vr c p t | t r t dg d | dd }|S ||dk( rt j | }t j | }|st
d|z |j t j g d ddi} |j | fi |\ }}t | d kD r%|d d
k( r |j |d d }|d d }n1t | d kD r!|d d k( rt |j | d d d
d} t dg d ||| }|S # t $ r i }Y w xY w)a9 Takes a string (or byte array) and tries to convert it to a Unicode string.
Returns a named tuple: (string, codec, bom)
The 'encoding' argument, if supplied, should either the name of
a character encoding, or an instance of codecs.CodecInfo. If
the encoding argument is None or "auto" then the encoding is
automatically determined, if possible.
Any BOM (Byte Order Mark) that is found at the beginning of the
input will be stripped off and placed in the 'bom' portion of
the returned value.
DecodedString)stringcodecbomNautoz"Can not find codec for encoding %rr )r r r u r
u z+Wrong byte order, found reversed BOM U+FFFE)r> rD rF r r r r r rT rC r r r r )ry r resr cdk_kwunitxtnumbytesr s r unicode_decodezhelpers.unicode_decodeh sf c3 J+o/IJT4CF
? 8v#5"77<&&x0C!"F"QRR
.
711"5h
G #H- )szz# 8 8 FH 6{Q6!9#8jj+A. Vq VAY(%:(HHc1a)V J+o/IJSC
+
s +&D' ' D54D5c t | t | }}|dk s|dkD s
|dk s|dkD rt d| |f |dz
}|dz
}|dz |z }|dz
}t j | S )zTakes a pair of unicode surrogates and returns the equivalent unicode character.
The input pair must be a surrogate pair, with c1 in the range
U+D800 to U+DBFF and c2 in the range U+DC00 to U+DFFF.
r r z illegal Unicode surrogate pairr2 rb )r JSONDecodeErrorr r )c1c2n1n2rO rQ r` s r surrogate_pair_as_unicodez!helpers.surrogate_pair_as_unicode sy R#b'B
;"v+fV !"BRHM M K K
"WM W ""1%%r c t | }t j | \ }}| t | fS t | t | fS )a Takes a single unicode character and returns a sequence of surrogate pairs.
The output of this function is a tuple consisting of one or two unicode
characters, such that if the input character is outside the BMP range
then the output is a two-character surrogate pair representing that character.
If the input character is inside the BMP then the output tuple will have
just a single character...the same one.
)r r rc r
)r r& re rf s r unicode_as_surrogate_pairz!helpers.unicode_as_surrogate_pair sE
F,,Q/B
:G: GSW% %r c T | dk r| dfS | dz
}|dz dz }|dz }d|z }d|z }||fS )zJGiven a Unicode codepoint (int) returns a 2-tuple of surrogate codepoints.rb Nr2 i r r r )rd r` vhvlre rf s r rc zhelpers.make_surrogate_pair sS w t$ $ 2g
Y
b[
b[Bxr c t | t t f xr t | t xs@ | t u xs6 | t
u xs, | t u xs" t xr t | t j S )z:Is the object of a Python number type (excluding complex)?) r> intrB boolrm rn r r9 r< )r s r isnumbertypezhelpers.isnumbertype sk
sS%L )
* sD))
>cz
> cz
> f}
>
rB reprr r9 r< r# is_signedr% s r
is_negzerozhelpers.is_negzero sV a 87Q 2 23 7 7
Aw799;01;;= 0r c t | t r$| t u xs | j dk( xs | | k7 S t r*t | t j
r| j
S y)z#Is the number a NaN (not-a-number)?rm F)r> rB rm hexr9 r< is_nanr% s r r zhelpers.is_nan sP a 89quuw% /916 9
Aw788: r c t | t r&| t u xs | t u xs | j dv S t
r*t | t
j r| j S y)zIs the number infinite?)rn ro F)r> rB rn r r r9 r< is_infiniter% s r r zhelpers.is_infinite sP a 8HqF{Haeeg .H H
Aw7==? "r c ~ t | t ryddl}t | t f xs t | |j S )z&Is the object of a Python string type?Tr N)r> rD collections
UserString)r r s r isstringtypezhelpers.isstringtype s5 c3 #v&Q*S+:P:P*QQr c 0 d}| D ] }d|cxk rdk rn nt | t d z
}n^d|cxk rdk r n nt | t d z
dz }n5d|cxk rdk r n nt | t d z
dz }n t d | |d
z |z } |S ) z5Decodes a hexadecimal string into it's integer value.r r, 9rO r[ r2 AFzNot a hexadecimal number r r8 ) hexstringr& r rv s r
decode_hexzhelpers.decode_hex s
Aa3FSX% S FSX%* S FSX%* !;YGGR1 A
r c d}| D ]< }d|cxk rdk rn nt | t d z
}n t d| |dz |z }> |S )z0Decodes an octal string into it's integer value.r r, 7zNot an octal number r ) octalstringr& r rv s r decode_octalzhelpers.decode_octal sW
Aa3FSX% !6 DDQ! A
r c ` d}| D ]& }|dk( rd}n|dk( rd}n t d| |dz |z }( |S )z0Decodes a binary string into it's integer value.r r, r+ r
zNot an binary numberr. )r8 ) binarystringr& r rv s r
decode_binaryzhelpers.decode_binary$ sR
ACxc !7 FFQ! A r c | j }| j }| j }t |d \ }}t |d \ }}dg}|r|j d|z |s|s|s|r|j d |r|j d|z |r|j d|z |s|r-|r|j d||fz n|j d|z t | d k( r|j d
d j
| S ) z>Encodes a datetime.timedelta into ISO-8601 Time Period format.< Pz%dDTz%dHz%dMz%d.%06dz%dr
T0Sr )daysseconds microsecondsdivmodr r r )tdrv rY msr] hrO s r format_timedelta_isoz helpers.format_timedelta_iso3 s
GG JJ
__a}1a}1
E
HHUQY Q"
HHSM
HHUQY
HHUQY aW,-" q6Q;
HHUOwwqzr r r )*r r r r rV rZ r# r r| r r~ frozensetjavascript_reserved_wordsr rT rX r[ r] r` r rj rl rn rr rv r r{ r r r r r rc r r r r r r r r r r r r r r 9 ss %(I K35 J $ !*1
3! j * * & & ( ( $ $ / / ' ' ( ( 4 4 " " : 8 X Xt 3 3j & & & &$
R R &
r r c e Zd ZdZddZed Zed Zed Zed Z ed Z
e
j d Z
ed
Z e j d Z d Z
dd
Zd Zd Zd Zd Zy)position_markera A position marks a specific place in a text document.
It consists of the following attributes:
* line - The line number, starting at 1
* column - The column on the line, starting at 0
* char_position - The number of characters from the start of
the document, starting at 0
* text_after - (optional) a short excerpt of the text of
document starting at the current position
Lines are separated by any Unicode line separator character. As an
exception a CR+LF character pair is treated as being a single line
separator demarcation.
Columns are simply a measure of the number of characters after the
start of a new line, starting at 0. Visual effects caused by
Unicode characters such as combining characters, bidirectional
text, zero-width characters and so on do not affect the
computation of the column regardless of visual appearance.
The char_position is a count of the number of characters since the
beginning of the document, starting at 0. As used within the
buffered_stream class, if the document starts with a Unicode Byte
Order Mark (BOM), the BOM prefix is NOT INCLUDED in the count.
Nc X || _ || _ || _ || _ d| _ d| _ y r ) _position_marker__char_position_position_marker__line_position_marker__column _position_marker__text_after_position_marker__at_end _position_marker__last_was_cr)r offsetlinecolumn
text_afters r __init__zposition_marker.__init__o s/ %
&
"r c | j S )z2The current line within the document, starts at 1.)r r s r r zposition_marker.linew s {{r c | j S )z^The current character column from the beginning of the
document, starts at 0.
)r r s r r zposition_marker.column| s
}} r c | j S )z^The current character offset from the beginning of the
document, starts at 0.
)r r s r
char_positionz position_marker.char_position s
###r c | j dk( S )z=Returns True if the position is at the start of the document.r )r r s r at_startzposition_marker.at_start s !!Q&&r c | j S )ztReturns True if the position is at the end of the document.
This property must be set by the user.
r r s r at_endzposition_marker.at_end }} r c $ t | | _ y)z*Sets the at_end property to True or False.N)r r )r rQ s r r zposition_marker.at_end s Q
r c | j S )ztReturns a textual excerpt starting at the current position.
This property must be set by the user.
r r s r r zposition_marker.text_after r r c || _ y)z/Sets the text_after property to a given string.N)r )r values r r zposition_marker.text_after s "r c | j j d| j d| j d| j }| j
r|d| j
z
}|dz
}|S )Nz(offset=z,line=z,column=z ,text_after=))r r r r r r r rY s r re zposition_marker.__repr__ sU NN # # KK MM
??
T__6 6A Sr c d| j | j | j fz }| j r|dz
}n| j r|dz
}|r | j
r|d| j
z z
}|S )zAReturns a human-readable description of the position, in English.z line %d, column %d, offset %dz (AT-START)z (AT-END)z , text %r)r r r r r r )r show_textrY s r describezposition_marker.describe sm + KK MM /
==
A
[[
A
0 0Ar c & | j d S )z Same as the describe() function.Tr )r r s r rh zposition_marker.__str__ s }}t},,r c | j }| j |_ | j |_ | j |_ | j |_ | j |_ | j |_ |S )z%Create a copy of the position object.)r r r r r r r r r ps r copyzposition_marker.copy s\ NN 0 0;;]]
(( ;; ,,r c p | j sd| _ d| _ d| _ d| _ d| _ d| _ y)z.Set the position to the start of the document.NFr r
)r r r r r r r r s r rewindzposition_marker.rewind s5 }} "DO DK
"r c 0 |rd| _ |D ] }| xj dz
c_ |dk( r| j rd| _ 1t j | r'| xj
dz
c_ d| _ |dk( | _ m| xj dz
c_ d| _ y)zjAdvance the position from its current place according to
the given string of characters.
Nr
Fr
)r r r r rn r r )r rY r s r advancezposition_marker.advance s
"DO
+A A % DyT / /%*",,Q/ q !
%&$Y"
"
%*"
+r )r r
r NT)r r r r r r r r r r r setterr re r rh r r r r r r r r S s 6# $ $ ' ' ]] " "
- #+r r c D e Zd ZdZd&dZd Zd Zd Zd Zd Z d'd Z
d
Z d Z e
d Ze
d
Ze
d Ze
d Ze
d Ze
d Zd(dZd(dZd)dZd*dZe
d+d Zd Zd,dZd Zd Z d(dZ d(d Z d Z d*d Z d Z!d Z"d'd!Z#d" Z$d'd#Z%d'd$Z&d% Z'y)-buffered_streamzA helper class for the JSON parser.
It allows for reading an input document, while handling some
low-level Unicode issues as well as tracking the current position
in terms of line and column position.
Nc H | j | j || y r )resetset_text)r ry r s r r zbuffered_stream.__init__ s
c8$r c t | _ g | _ t j g | _ d| _ d| _ d| _ d| _ d| _
d| _ d| _ y)z Clears the state to nothing.NFr )
r _buffered_stream__pos_buffered_stream__saved_posr rT _buffered_stream__bom_buffered_stream__codec_buffered_stream__encoding _buffered_stream__input_is_bytes_buffered_stream__rawbuf_buffered_stream__raw_bytes_buffered_stream__cmaxnum_ws_skippedr s r r zbuffered_stream.reset s_ $&
++
%
r c j | j j | j j y)NT)r r r r r s r
save_positionz buffered_stream.save_position s$
12r c R | j r| j j yyNTF)r popr s r clear_saved_positionz$buffered_stream.clear_saved_position s# "r c | j j }|| _ y# t $ r}t d |d }~ww xY w)NTz7Attempt to restore buffer position that was never saved)r r# r
IndexError)r old_poserrs r restore_positionz buffered_stream.restore_position sJ &&**,G !DJ a VW]` ` as $ > 9>c T |d | _ d | _ | j S t |t j r.|| _ | j j
| _ | j S || _ t j | | _ | j s t d| | j S )N)no codec available for character encoding) r r r> r r r r r r )r r s r _find_codeczbuffered_stream._find_codec& s DL "DO || &"2"2
3#DL "ll / /DO ||
'DO"//9DL<<%? ||r c t | j d| _ d| _ d| _ d| _ t
j
|| }|j | _ |j | _ |j | _ t | j | _ y# t $ r t $ r}t d }||d}~ww xY w)zlChanges the input text document and rewinds the position to
the start of the new document.
Nr r z!a Unicode decoding error occurred)r r r r r r r r r r r JSONError Exceptionr )r ry r decodedr( newerrs r r zbuffered_stream.set_text6 s
- ,,S(;G #==DL DJ #NNDM dmm,DK "$%HIFc ! "s B B7$B22B7c j d| j j d| j d| j dS )N)r r r text_contextr s r re zbuffered_stream.__repr__O s) NN # # JJ
r c 8 | j j y)z8Resets the position back to the start of the input text.N)r r r s r r zbuffered_stream.rewindV s
r c | j S )z;The codec object used to perform Unicode decoding, or None.)r r s r r zbuffered_stream.codecZ s ||r c | j S )zThe Unicode Byte-Order Mark (BOM), if any, that was present
at the start of the input text. The returned BOM is a string
of the raw bytes, and is not Unicode-decoded.
)r r s r r zbuffered_stream.bom_ s zzr c . | j j S )z. s
F1I
r )rX )r rW s `r skipwhilezbuffered_stream.skipwhile s ~~ 566r c | j j } | j }|r| j j |kD r)|dk( r#| j dk( r| j yU)zAdvances the current position to the start of the next
line. Will not advance beyond the end of the file. Note that
the two-character sequence CR+LF is recognized as being just a
single end-of-line marker.
r r
N)r r r# r? rU )r rE lnr s r skip_to_next_linez!buffered_stream.skip_to_next_line sV ZZ__
A
",9!4IIK r c |r | j t j }n | j t j }| xj |z
c_ |S )zqAdvances the current position past all whitespace, or until
the end of the document is reached.
)r\ r rj r` r )r rB r& s r skipwszbuffered_stream.skipws sE
$w 9 9:Aw 6 67A q r c ` | j }|r| j j | |S )zReturns the character at the current position and advances
the position to the next character. At the end of the
document this function returns an empty string.
r? r r r@ s r r# zbuffered_stream.pop# s)
IIK JJ q !r c b | j | }|r| j j | |S )a' Returns a string of one or more characters starting at the
current position, and advances the position to the following
character after the span. Will not go beyond the end of the
document, so the returned string may be shorter than the
requested span.
)rL r r )r rJ r rY s r popstrzbuffered_stream.popstr. s,
LL JJ q !r c r | j }|r% || r | j j | |S y)z|Just like the pop() function, but only returns the
character if the given predicate test function succeeds.
r rc )r rW r s r popifzbuffered_stream.popif; s2
IIK JJ q !Hr c t t t f s t | j }|r|v r| j fd }|S y)zPops a sequence of characters at the current position
as long as each of them is in the given set of characters.
c | xr | v S r r )r r s r r' z.buffered_stream.pop_while_in..N s (8a5j r N)r> setr r? popwhile)r r r rY s ` r pop_while_inz buffered_stream.pop_while_inE sH
%#y!12JE IIK e
89AHr c | j }|r6t j | r!| j t j }|S y)z|Pops the sequence of characters at the current position
that match the syntax for a JavaScript identifier.
N)r? r rr rk rv )r matchr rY s r pop_identifierz buffered_stream.pop_identifierR s;
IIK 2215
g = =>AHr c | | j t | }||k7 ry| j j | |S )zpPops the sequence of characters if they match the given string.
See also method: startswith()
N)rL r r r rR s r pop_if_startswithz!buffered_stream.pop_if_startswith] s7 \\#a&
!
7
2 r c g }d}|||k r3| j | }|sn |j | |dz
}|-||k r3dj | S )ak Pops all the characters starting at the current position as
long as each character passes the given predicate function
test. If maxchars a numeric value instead of None then then
no more than that number of characters will be popped
regardless of the predicate test.
See also methods: skipwhile() and popuntil()
r r
r )rg r r )r rW maxcharsrY r r s r rk zbuffered_stream.popwhilei s`
!h,
6"A
HHQK
FA !h, wwqzr c 0 | j fd| S )zJust like popwhile() method except the predicate function
should return True to stop the sequence rather than False.
See also methods: skipuntil() and popwhile()
c | S r r r[ s r r' z*buffered_stream.popuntil.. s
6!9} r rs )rk )r rW rs s ` r popuntilzbuffered_stream.popuntil} s }} 4x}HHr c t |t r3| j |j |j z
|j S | j | S )a Returns the character at the given index relative to the current position.
If the index goes beyond the end of the input, or prior to the
start when negative, then '' is returned.
If the index provided is a slice object, then that range of
characters is returned as a string. Note that a stride value other
than 1 is not supported in the slice. To use a slice, do:
s = my_stream[ 1:4 ]
)r> slicerL stopr r? )r indexs r __getitem__zbuffered_stream.__getitem__ s? eU #<<
U[[ 8%++F F99U# #r )r Nr r
r r
r ) )r
)(r r r r r r r r$ r) r, r re r r r r r: r< r r rC rF r? rL r5 r rU rX r\ r_ ra r# re rg rl ro rq rk rw r| r r r r r s %
-2
( ( # # . /
" .7
(I$r r c e Zd ZdZy)
JSONExceptionz+Base class for all JSON-related exceptions.Nr r r r r r r r r s 5r r c e Zd ZdZy) JSONSkipHookzAn exception to be raised by user-defined code within hook
callbacks to indicate the callback does not want to handle the
situation.
Nr r r r r r r r c e Zd ZdZy)JSONStopProcessingzCan be raised by anyplace, including inside a hook function, to
cause the entire encode or decode process to immediately stop
with an error.
Nr r r r r r r r r c e Zd Zy) JSONAbortN)r r r r r r r r s r r c x e Zd ZdZ eg d Z fdZed Zej d Zd Z
ddZ xZ S ) r. a| Base class for all JSON-related errors.
In addition to standard Python exceptions, these exceptions may
also have additional properties:
* severity - One of: 'fatal', 'error', 'warning', 'info'
* position - An indication of the position in the input where the error occured.
* outer_position - A secondary position (optional) that gives
the location of the outer data item in which the error
occured, such as the beginning of a string or an array.
* context_description - A string that identifies the context
in which the error occured. Default is "Context".
)fatalerrorwarninginfoc d| _ d | _ d | _ d | _ t |j D ] \ }}|dk( r:|| j vr$t | j j d| || _ E|dk( r|| _
R|dk( r|| _ _|dk( s|dk( r|| _ qt | j j d|d t t | 6 |g| || _ y )
Nr severityz given invalid severity r< outer_positioncontext_descriptioncontextz does not accept z keyword argument)r _positionr r listitems
severitiesrC r r r< r r. r message)r r r r kwvalr s r r zJSONError.__init__ s
"#' FLLN+ GBZ doo-#:>..:Q:QSVW !$
z! #
''&)#,,i+.( ~~..4 $ i'7$7 r c | j S r r r s r r< zJSONError.position s ~~ r c , |dk( rd| _ y || _ y r) r )r r s r r< zJSONError.position s !8 DN DNr c & | j j d| j }| j dd D ]
}|d|z
} | j r|d| j z
}| j
r|d| j
z
}|d| j dz
}|S )N(r
, z , position=z, outer_position=z , severity=r )r r r r r< r r )r rY rO s r re zJSONError.__repr__ s ~~.. =12 A
1 A ==
DMM3 3A
$*=*=? ?A
00r c t |r#|j j d dz }nd}|}| j dk( r|dz
}nD| j r3|d| j j | j j fz z
}n|dz
}|d| j j d| j z
}t | j d kD rU|dz
}t | j d d D ]5 \ }}|d kD r|d
z
}t | }t | d kD r|d d d z }||z
}7 | }|rt |d
rt |j t rg|j }t | j! } | st | j! } |d| j! j# dd z z
}nd }|r|ru| j i| j dk( r|dz
}nT|d| j j% d z
}| j j& r |d| j j& z
}|r| j( r| j* r| j* j }
nd}
|d|
d| j( j% d z
}| j( j& r |d| j( j& z
}|S )N:r r z0:0:z%d:%d:z : r
r rN __cause__z
| Cause: %sr
z
| z
| At start of inputz
| At Fr z
| near text: r? z
| z started at z
| with text: )rstripr< r r r
capitalizer r r r r r r> r r/ rD stripr r r r r ) r show_positionsfilenamerN r( anumrO astre2e2desccdescs r pretty_descriptionz JSONError.pretty_description s //#**3/#5CC ==A 6MC
]] 8t}} 1 14==3G3G HH HC 6MC DMM 4 4 6 EE tyy>A 4KC$TYYqr]3
a!84KCAwt9r> 9u,Dt
r;'Jr||Y,O\\ R !"X^^ -F*V\\^-C-C+. dmm 7}}!22$--*@*@5*@*QSS==++
8P8PRRC d 1 1'' 00;;=! ##,,u,=
C ""--D4G4G4R4RTT
r )TN)
r r r r r r r r r< r re r r r s @r r. r. sP @AJ 4 __! ! 9r r. c e Zd ZdZy)r zKAn exception class raised when a JSON decoding error (syntax error) occurs.Nr r r r r r 9 s Ur r c " e Zd ZdZ fdZ xZS )JSONDecodeHookErrorzAn exception that occured within a decoder hook.
The original exception is available in the 'hook_exception' attribute.
c p || _ |sd}|\ }| _ | _ t | | _ d|d| j | j j
j nd d| j j d}t | dk\ r|dt |d z z
}|dd }t t | . |g|i | y ) Nr Hook raised z while decoding type 4#d1g,& &C8D
!41#GGGr r r r r r r r s @r r r ?
H Hr r c e Zd ZdZy)JSONEncodeErrorzSAn exception class raised when a python object can not be encoded as a JSON string.Nr r r r r r X s ]r r c " e Zd ZdZ fdZ xZS )JSONEncodeHookErrorzAn exception that occured within an encoder hook.
The original exception is available in the 'hook_exception' attribute.
c || _ |sd}|\ }| _ | _ t | | _ d| j d| j | j j
j nd d| j j d}t | dk\ r|dt |d z z
}|dd }t t | . |g|i | y ) Nr r r z while encoding type 4#d1g,& &C8D
!41#GGGr r r s @r r r ^ r r r c < e Zd ZdZd
dZd Zd Zd Zd Zd Z d Z
y) encode_statezjAn internal transient object used during JSON encoding to
record the current construction state.
Nc g | _ |s d | _ d| _ || _ d| _ y || _ |j dz | _ |j | _ |j | _ y )Nr Fr
)chunksparent
nest_leveloptionsescape_unicode_test)r jsoptsr s r r zencode_state.__init__ s[ DK DO!DL',D $ DK $ / /! 3DO'-'A'AD $!>>DLr c t | S )N)r )r r s r
make_substatezencode_state.make_substate s
4((r c \ | j j |j g |_ y r )r r r other_states r
join_substatezencode_state.join_substate s" ;--. r c : | j j | y)z5Adds a string to the end of the current JSON documentN)r r r s r r zencode_state.append s 1 r c J dj | j }g | _ |S )z ??k 4 4 4??[%;%;; ;{{[ / ///r r/ ) r r r r r r r r r r r r r r r r | s*
* )
0r r c V e Zd ZdZdZdZdZdZdZdZ dZ
d Z d
Z d Z
d Zed
ZddZy)decode_statisticszHAn object that records various statistics about a decoded JSON document.r ii i ii l l l l c d| _ d| _ d| _ d| _ d| _ d| _ d| _ d| _ d| _ d| _ d| _
d| _ d| _ d| _
d| _ d| _ d| _ d| _ d | _ d | _ d| _ d| _ d| _ d| _ d| _ d| _ d| _ d| _ d| _ d| _ y r) ) max_depthmax_items_in_arraymax_items_in_objectnum_ints
num_ints_8bitnum_ints_16bitnum_ints_32bitnum_ints_53bitnum_ints_64bit
num_ints_longnum_negative_zero_ints total_charsnum_negative_zero_floats
num_floatsnum_floats_decimal num_stringsmax_string_lengthtotal_string_length
min_codepoint
max_codepoint
num_arrays num_objects num_bools num_nullsnum_undefinedsnum_nansnum_infinities num_commentsnum_identifiersnum_excess_whitespacer s r r zdecode_statistics.__init__ s "# #$
&'# ()%"# !" #$ ! !
%&"r c | j S )z7Misspelled 'num_infinities' for backwards compatibility)r r s r
num_infinitesz decode_statistics.num_infinites s """r c z dd l }dd| j | j | j fz d| j | j
| j fz d| j | j | j fz d| j | j | j fz d| j | j | j fz d| j z d | j" z d
| j$ z d d | j& z d
| j( z d| j& | j( z z d| j* z dd| j, z d| j. z d| j0 z d| j2 z dd| j4 z d| j6 z d| j8 z g}| j: Nd| j: z } |j= t? | j: }|jC d|d d |d n|jC d d z | jD Nd| jD z } |j= t? | jD }|jC d!|d d |d n|jC d"d z |jG d#d$| jH z d%| jJ z d&| jL z d'| jN z d(| jP z d)| jR z d*| jT z d+| jV z g | jX dk( r|jC d, nE|jC d-| jZ | jX | jZ d.z | jX z fz |r%d/j] |D cg c] }||z c} d/z S d/j] | d/z S # t@ $ r d}Y w xY w# t@ $ r d}Y qw xY wc c}w )0Nr zNumber of integers:z 8-bit: %5d (%d to %d)z 16-bit: %5d (%d to %d)z 32-bit: %5d (%d to %d)z6 > 53-bit: %5d (%d to %d - overflows JavaScript)z 64-bit: %5d (%d to %d)zD > 64 bit: %5d (not portable, may require a "Big Num" package)z total ints: %5dz> Num -0: %5d (negative-zero integers are not portable)zNumber of floats:z doubles: %5dz1 > doubles: %5d (will overflow IEEE doubles)z total flts: %5dz@ Num -0.0: %5d (negative-zero floats are usually portable)z
Number of:z nulls: %5dz booleans: %5dz arrays: %5dz objects: %5dzStrings:z number: %5d stringsz! max length: %5d charactersz) total chars: %5d across all stringsU+%04Xz? UNKNOWN CHARACTERz min codepoint: z>6z (r z min codepoint: %6s)zn/az max codepoint: z max codepoint: %6szOther JavaScript items:z NaN: %5dz Infinite: %5dz undefined: %5dz Comments: %5dz Identifiers: %5dzMax items in any array: %5dzMax keys in any object: %5dzMax nesting depth: %5dz-Unnecessary whitespace: 0 of 0 charactersz5Unnecessary whitespace: %5d of %d characters (%.2f%%)g Y@r
)/r! r int8_minint8_maxr int16_min int16_maxr int32_min int32_maxr double_int_mindouble_int_maxr int64_min int64_maxr r r r r r r r r r r r r r r r
r8 r r r r r r r r r r r r r r )r prefixr! linescpcharnamerY s r r z$decode_statistics.pretty_description s
" -!!4==$--@
A -""DNNDNNC
D -""DNNDNNC
D D""D$7$79L9LM
N -""DNNDNNC
D R
! 4== 0 L))
* 4?? 2 ?%%
& DOOd6M6M$M N N++
, 4>> 1 4>> 1 4?? 2 4#3#3 3 ,t/?/? ? /$2H2H H 7$:R:R RA!
F )D . ..B
1&++C0B0B,CD
LL"hG H LL08; < )D . ..B
1&++C0B0B,CD
LL"hG H LL08; <
)%
5%(;(;;%(;(;;%(9(99%(<(<<-0G0GG-0H0HH->
q LLH I LLG..$$..69I9II
99% 8Qfqj 89D@ @99U#d* *W
10
1
10
1> 9s* 1$N $N& * N8 N#"N#& N54N5Nr )r r r r r r r r r r r
r r r
r r r r r r r r r sW RHHIII I"I'I N#N#'J # #U+r r c e Zd ZdZddZd Zed Zed Zed Z ddZ
d Z d
Z d Z
d Zd
Zd Zd Zd Zd Zd Zd Zd Zd Zy) decode_statezxAn internal transient object used during JSON decoding to
record the current parsing state and error messages.
Nc 2 | j || _ y r )r r )r r s r r zdecode_state.__init__N s
r c d| _ g | _ d| _ d| _ t | _ d| _ d| _ d| _ y)z.Clears all errors, statistics, and input text.Nr F) bufr r cur_depthr stats_have_warned_nonbmp_have_warned_long_string_have_warned_max_depthr s r r zdecode_state.resetR s@ &(
#( (-%&+#r c | j ryyr" ) has_fatalr s r should_stopzdecode_state.should_stop] s >>r c v t | j D cg c] }|j dv s| c} dkD S c c}w )"Have any errors been seen already?r r r r r r r r( s r
has_errorszdecode_state.has_errorsc s5
Rs||?Q/QR SVW W
R 66c v t | j D cg c] }|j dv s| c} dkD S c c}w )r )r r r" r# s r r zdecode_state.has_fatalj s2 4;;MC#,,*2LCMNQRRRMr% c : | j t || | _ | j j r<| j | j
j d| j j | j s| j dd yy# t $ r)}d|_ d|_ | j | Y d}~Nd}~wt $ rJ}t ddd } ||# t $ r}| j | Y d}~nd}~ww xY wd| _ Y d}~d}~ww xY w)
z8Initialize the state by setting the input document text.r z5JSON document was prefixed by a BOM (Byte Order Mark)r r NzError while reading inputr< r z%Aborting, can not read JSON document.r< )
r r r r push_condr r. r< r push_exceptionr/ r
push_fatal)r ry r r( r1 s r set_inputzdecode_state.set_inputo s
&sX>DH xx||LL$$KHHLL
xx OO CaO P + % CL"CL $ $ $+a'F
) #%"
)##C((
)DHH sG B D C DD C"" D+D<DD
DDc : | j j | y)z1Add an already-built exception to the error list.N)r r )r excs r r, zdecode_state.push_exception s 3 r c : d|d< | j |g|i | y)zCreate a fatal error.r r N_decode_state__push_errr r r r s r r- zdecode_state.push_fatal $ $z1$1&1r c : d|d< | j |g|i | y)zCreate an error.r r Nr2 r4 s r
push_errorzdecode_state.push_error r5 r c : d|d< | j |g|i | y)zCreate a warning.r r Nr2 r4 s r push_warningzdecode_state.push_warning s$ &z1$1&1r c : d|d< | j |g|i | y)z Create a informational message.r r Nr2 r4 s r push_infozdecode_state.push_info s$ #z1$1&1r c l |t k( ry|t k( rd|d< nd|d< | j |g|i | y)zCreates an conditional error or warning message.
The behavior value (from json_options) controls whether
a message will be pushed and whether it is an error
or warning message.
Nr r r )ALLOWWARNr3 )r behavior_valuer r r s r r+ zdecode_state.push_cond sC U "
t
#!*F: !(F: 1$1&1r c D d}d}d}d}t |j D ]5 \ }} |dk( r| }|dk( r| }|dk( r| } |dk( s|dk( r| }+t d| |"| j r| j j }t |g|||||d }
| j
|
y)
z"Stores an error in the error list.Nr r< r r r r zUnknown keyword argument)r< r r r )r r rC r r< r r, ) r r r r r< r r r r r r( s r
__push_errzdecode_state.__push_err s "FLLN+
@GBZ ''!$z! ,,i&)# :B??
@ xx((H
) 3
C r c P | j }t |j | j |_ | j si| j | j
j kD rEd| _ | j | j
j d| j
j z y y y )NTzBArrays or objects nested deeper than %d levels may not be portable) r rO r r r r warn_max_depthr+ non_portabler r sts r update_depth_statsz decode_state.update_depth_stats s
ZZ2<< 8 ++ !&>+/( LL--X '?~ r c | j }|xj dz
c_ |j dk( r) | j | j j dfi | y y )Nr
z4Negative zero (-0) integers are usually not portable)r r r+ r rD rE s r update_negzero_int_statsz%decode_state.update_negzero_int_stats
sW
ZZ
!!Q&!
$ $ ) DNN ))F
*r c | j }|xj dz
c_ |j dk( r) | j | j j dfi | y y )Nr
z0Negative zero (-0.0) numbers may not be portable)r r r+ r rD rE s r update_negzero_float_statsz'decode_state.update_negzero_float_stats
sW
ZZ
##q(#
& &! + DNN ))B
,r c | j }d|v r|d= t j | r | j di | t j | r|xj
dz
c_ t
|t j rN|xj dz
c_ |j dk( r) | j | j j dfi | y y t
|t r|xj dz
c_ y y )Nsignr
zGFloats larger or more precise than an IEEE "double" may not be portabler )r r r rP r r r> r9 r< r r+ r rD rB r )r float_valuer rF s r update_float_statsz decode_state.update_float_stats
s
ZZ V v k * +D + + 5f 5 { + " k7?? 3 ! !Q & !$$) LL--] * U
+ MMQ M ,r c |j dd }d|v r|d= |dk( r|dk r | j di | |dk r| }| j }|xj dz
c_ |j |cxk r|j
k rn n|xj dz
c_ n|j |cxk r|j k rn n|xj dz
c_ n|j |cxk r|j k rn n|xj dz
c_ nM|j |cxk r|j k rn n|xj dz
c_ n|xj dz
c_ ||j" k s|j$ |k rN|xj& dz
c_ |j& dk( r) | j( | j* j, dfi | y y y )NrR r
r z-Integers larger than 53-bits are not portabler )getrN r r r r r r r r r r r r r
r r r
r r r+ r rD )r int_valuer rR rF s r update_integer_statsz!decode_state.update_integer_stats-
s| zz&!$ V v >dQh )D ) ) 3F 3 !8"
I
ZZ
q
;;) 2r{{ 2 !
\\Y
6",,
6 "
\\Y
6",,
6 "
\\Y
6",,
6 " ! r(( (B,=,= ,I " A% LL--C & -Jr r )r r r r r r r r r$ r r. r, r- r7 r9 r; r+ r3 rG rL rN rP rT rX r r r r r H s
,
S S Q< 2
2
2
2
2 !: !F , r r r warntolerantallowforbidr rB r9 r legacyoctaloctalbinaryc " e Zd ZdZ fdZ xZS )_behaviors_metaclassa Meta class used to establish a set of "behavior" options.
Classes that use this meta class must defined a class-level
variable called '_behaviors' that is a list of tuples, each of
which describes one behavior and is like: (behavior_name,
documentation). Also define a second class-level variable called
'_behavior_values' which is a list of the permitted values for
each behavior, each being strings.
For each behavior (e.g., pretty), and for each value (e.g.,
yes) the following methods/properties will be created:
* pretty - value of 'pretty' behavior (read-write)
* ispretty_yes - returns True if 'pretty' is 'yes'
For each value (e.g., pink) the following methods/properties
will be created:
* all_behaviors - set of all behaviors (read-only)
* pink_behaviors - set of behaviors with value of 'pink' (read-only)
* set_all('pink')
* set_all_pink() - set all behaviors to value of 'pink'
c , |j d }t d d |d< |j d }d }||d< d }||d
< d }||d < |D ] \ } }
d
|d| z < |D ]f } | dz | z } | | fd}
t |
| j dz |
z |d| z < | | fd}| |_ d| z dz | z dz |_ |||j < h | fd}| fd}t |||
|| < t d }||d< d |d < d |d < |D ]k } | fd }t |d | z dz || dz < | ffd! }d"| z |_ d#| z dz |_ |||j < t | ffd$ d%| z dz |d&| z < m d' }||d(< t
t | | ||| S ))N_behavior_valuesc , t | j S r )rj rc r s r r' z._behaviors_metaclass.__new__..
s T 2 23 r z Set of possible behavior values)docvalues
_behaviorsc T t | d|z S # t $ r
t d| w xY w)z&Returns the value for a given behavior
_behavior_Unknown behavior)getattrAttributeErrorr8 r r s r get_behaviorz2_behaviors_metaclass.__new__..get_behavior
s6
; t\D%899!
; !3T::
;s 'rn c || j vr t d| d|z }t | | rt | || yt d| )z&Changes the value for a given behaviorzUnknown value for behaviorri rj N)rc r8 r setattr)r r r varnames r set_behaviorz2_behaviors_metaclass.__new__..set_behavior
sL D 1 11 !=uEE"T)GtW%gu- !3T::r rr c T | j D ] \ }}||k( s |c S t d| )z-Returns documentation about a given behavior.zNo such behavior)rg rl )r r r& re s r describe_behaviorz7_behaviors_metaclass.__new__..describe_behavior
s5 //
?39 J
? %%7>>r rt Tri _c * | j | |k( S r rn )r r forvals r getxz*_behaviors_metaclass.__new__..getx
s ,,T2f<.
s 4;L;L6< r z
Set behavior z to .c $ | j | S r rw rm s r get_value_for_behaviorz<_behaviors_metaclass.__new__..get_value_for_behavior
s ((..r c ( | j || y r r| r r r s r set_value_for_behaviorz<_behaviors_metaclass.__new__..set_value_for_behavior
s !!$.r c X t | j D cg c] }|d c} S c c}w )z)Returns the names of all known behaviors.r )rj rg )r ts r
all_behaviorsz3_behaviors_metaclass.__new__..all_behaviors
s% doo6!67 76s 'r c z || j vr t d| | j D ] }t | d|z | y)z.Changes all behaviors to have the given value.rj ri N)rc r8 r rp r s r set_allz-_behaviors_metaclass.__new__..set_all
sD D 1 11 !3U;; **
:lT 159
:r r c || j vr t d| | j D ] }t | d|z |k7 s y y)z5Determines if all the behaviors have the given value.rj ri FT)rc r8 r rk r s r is_allz,_behaviors_metaclass.__new__..is_all
sO D 1 11 !3U;; **
!4 !45>
! r r c p t | j D cg c] }t | | |k( r| c} S c c}w r )rj r rk r s r getbehaviorsforz5_behaviors_metaclass.__new__..getbehaviorsfor
sA %)$6$6 "4.%7 s 3z+Return the set of behaviors with the value c | | S r r )r r~ r s r r' z._behaviors_metaclass.__new__..
s 74+@ r set_all_zSet all behaviors to value c | | S r r )r r` r s r r' z._behaviors_metaclass.__new__..
s
&q/ r z/Determines if all the behaviors have the value is_all_c h | j |j k7 ry| j |j k( S )z1Determines if two options objects are equivalent.F)r allowed_behaviorsr others r behaviors_eqz2_behaviors_metaclass.__new__..behaviors_eq
s0 !!U%8%88 ))U-D-DD Dr r )rV r r r r r ra r )r clsnamebasesattrsrf behaviorsrn rr rt r re r` vsry fnsetr r r r setfnr r r r s @@r r z _behaviors_metaclass.__new__
sJ -." 31
h IIl+ ; !-n ; !-n ? &7!"" ID#)-E,% &
.Wt^$( = %-allns 2S 8%ebj! ,0 "$ /$ 6 ?! Cc I
(-enn%
." 37
/ :>
/ #&(>CE$K3 :
8
8 "/o : #i !h A,-
'/ AAEK'E!l" #
)*@E '!^EN 9A = CEM$)E%.. !#+ 1EICO$E)a- + 4 E 'h)37WeUSSr )r r r r r r r s @r ra ra h
s 2AT ATr ra nonepreservealphaalpha_cismartz*Do not sort, resulting order may be randomz)Preserve original order when reformattingz Sort strictly alphabeticallyz$Sort alphabetically case-insensitivez-Sort alphabetically and numerically (DEFAULT)r c d}d}t d }| sd} | S t | t r|| z } | S t | t rt | }g }d}||k r| | |v rNd}||k r2| | |v r+|dz }|t | | |z
z
}|dz
}||k r| | |v r+|j ||z n'|j | | j
|dz
}||k rdj | } | S t | } | S )Nz%012d
0123456789r, r r r2 r
)r r> r rD r r r r )keynumfmtdigitsrL keylenwordsr nums r smart_sort_transformr s&
F
F s8D * J)
C sl& J%
C S
&j1v &jSVv%52IC3s1v;--CFA &jSVv%5 Vc\* SV\\^,Q &j ggen J #h Jr )Enum) OrderedDictc e Zd ZdZeeefZdZd Z d Z
d Z d Z d dZ
d dZd d
Zed Zej$ d Zed
Zej$ d Zed Zed Zed Zed Zed Zd efdZd!dZd!dZ ed Z e j$ d Z ed Z d Z ed Z ed Z!e!j$ d Z!y )" json_optionszAOptions to determine how strict the decoder or encoder should be.))all_numeric_signszStrings may contain raw control characters without \u-escaping) hex_numbersz Hexadecimal numbers, e.g., 0x1f)binary_numbersz Binary numbers, e.g., 0b1001)
octal_numberszKNew-style octal numbers, e.g., 0o731 (see leading-zeros for legacy octals))initial_decimal_pointzFFloating-point numbers may start with a decimal point (no units digit))extended_unicode_escapesz>Extended Unicode escape sequence \u{..} for non-BMP characters)js_string_escapesz=All JavaScript character \-escape sequences may be in strings)
leading_zeroszFNumbers may have extra leading zeros (see --leading-zero-radix option)) non_numbersz0Non-numbers may be used, such as NaN or Infinity)nonescape_characterszIUnknown character \-escape sequences stand for that character (\Q -> 'Q'))identifier_keyszHJavaScript identifiers are converted to strings when used as object keys)nonstring_keyszJValue types other than strings (or identifiers) may be used as object keys)omitted_array_elementszHArrays may have omitted/elided elements, e.g., [1,,3] == [1,undefined,3])single_quoted_stringszLStrings may be delimited with both double (") and single (') quotation marks)trailing_commaz9A final comma may end the list of array or object members)trailing_decimal_pointzUFloating-point number may end with a decimal point and no following fractional digits)undefined_valuesz,The JavaScript 'undefined' value may be used)format_control_charsz;Unicode "format control characters" may appear in the input)unicode_whitespacez:Treat any Unicode whitespace character as valid whitespace)r z Numbers may have leading zeros)duplicate_keysz Objects may have repeated keys) zero_bytezFStrings may contain U+0000, which may not be safe for C-based programs)r z>A JSON document may start with a Unicode BOM (Byte Order Mark))rD zGAnything technically valid but likely to cause data portablibity issuesc g d| _ t | _ d| _ t | _ d| _ t | _ t rt j nd | _ d| _ d| _
d| _ d| _ d| _ d | _ d| _ d| _ d| _ d| _ d| _ d| _ t0 | _ d | _ d
| _ d | _ d | _ d | _ y ) N)leading_zero_radixencode_namedtuple_as_objectencode_enum_asencode_compactlyescape_unicodealways_escape_charsrI rC int_as_floatdecimal_context
float_type keep_format date_formatdatetime_format time_formattimedelta_format sort_keys
indent_amountindent_tab_width indent_limitmax_items_per_linepy2str_encodingr FTr r @ isor. r r
) _plain_attrsSTRICTNESS_WARN
strictness_leading_zero_radix
SORT_SMART
_sort_keysr NUMBER_AUTOr r9 r= r r r _encode_enum_asr r r rI rC r r r r
SORT_ALPHAr r r r r r r s r reset_to_defaultsz json_options.reset_to_defaults s
2 *#$ $ !%9@w 5 5d +/( % $ #
#) $ % # ! "# $ r c | j d|v r
|d | _ t |j D ] \ }}|dk( r|| _ |dk( r|dk( r|s"| j 3|dk( s|dk( rNt
| sI| j t d | _ f| j j t d |dk( rE|s| j t | | _ | j j t | |d k( rt
| | _
|d
k( rt
| | _ |d k( rD|t t t fv r || _ #t! d |d
|d| j" j$ |dk( s|dk( rt& s]|r|dk( rt& j( | _ {|dk( rt& j, | _ |dk( rt& j. | _ t1 |t& j2 r || _ t1 |t4 s|d j6 r(t5 | }t' j2 | | _ t! d|d |dv rt8 t: t< t< t< d| }t1 |t> r=|jA dd jC D cg c] }|jA dd }}|D ] }| jE || |jG d sD|jG d s3|jG d s"|jG d s|jG d! r|jC d d" \ }}|d#k( r2|r| jE |t8 @| jE |t< X|d$v r2|r| jE |t< v| jE |t8 |d%k( s|r| jE |t: | jE |t8 || jH v rtK | || t! d&|d| j" j$ yc c}w )'a Set JSON encoding and decoding options.
If 'strict' is set to True, then only strictly-conforming JSON
output will be produced. Note that this means that some types
of values may not be convertable and will result in a
JSONEncodeError exception.
If 'compactly' is set to True, then the resulting string will
have all extraneous white space removed; if False then the
string will be "pretty printed" with whitespace and indentation
added to make it more readable.
If 'escape_unicode' is set to True, then all non-ASCII characters
will be represented as a unicode escape sequence; if False then
the actual real unicode character will be inserted if possible.
The 'escape_unicode' can also be a function, which when called
with a single argument of a unicode character will return True
if the character should be escaped or False if it should not.
r compactlywarnings html_safexml_safeNz<>/&
always_escaper r r zUnknown option z for argument z to initialize r9 r r. basicextendedr )precz Option for zi should be a decimal.Context, a number of significant digits, or one of 'default','basic', or 'extended'.)r[ rY r\ preventdeny,r r1 ru allow_forbid_prevent_deny_warn_r
r[ )r\ r r rY zUnknown keyword argument )&r r r r r suppress_warningsr r rj updater r r NUMBER_FLOATNUMBER_DECIMALr r8 r r r9 r= r BasicContextExtendedContextr> r? r rE r= r> FORBIDrD r splitrr r r rp )r r r r r actionrQ behaviors r r zjson_options.__init__ s ,
v $X .DOFLLN+ [ GB[ (+%x z!**,{"bJ&69//736v;0 0077F D&//736s80 0077CA~%$(I!}$#'9 |#; nEE&)DO$ DNN$;$;= y B*;$; #"2/6/E/E, /6/C/C,
*/6/F/F,#C 9/2,#C-Q "3x/6D/I, ( ! $ EE " $ % "
c3'8; C8M8S8S8UV1199S#.VCV # 8H%%h78
h'==+==,==)==)#%88C#3 W$ ))(E: ))(F; << ))(F; ))(E:v% ))(D9 ))(E:t(((b#& 4>>224 q[ v Ws 9Qc H | j }|j | |S r )r copy_fromr s r r zjson_options.copyL s
r c | |u ry |j | _ | j D ]# }| j ||j | % | j D ]q }t || }t
|t r|j }n5t r/t
|t j rt j | }t | || s y r ) r r rr rn r rk r> rj r r9 r< rp )r r r r s r r zjson_options.copy_fromQ s 5= **&& >D dE$6$6t$< = > %% %D%&C#s#hhjZW__ = ooc* D$ $ %r c P | j |z
}|dk rd}t || }d|z S )Nr r )r rO )r
min_spacessubtractr& s r spaces_to_next_indent_levelz(json_options.spaces_to_next_indent_levelc s3 ) q5A
A Qwr c | j || j kD r
| j }n|}|| j z }| j r$t || j \ }}d|z d|z z S d|z S )z/Returns a whitespace string used for indenting.r r )r r r r )r levelr& twsws r indentation_for_levelz"json_options.indentation_for_levelj sv (UT5F5F-F!!AA T
At 4 45FB"9sRx' '7Nr Nc f t | }|dk r t d| || _ || _ || _ y)a Changes the indentation properties when outputting JSON in non-compact mode.
'num_spaces' is the number of spaces to insert for each level
of indentation, which defaults to 2.
'tab_width', if not 0, is the number of spaces which is equivalent
to one tab character. Tabs will be output where possible rather
than runs of spaces.
'limit', if not None, is the maximum indentation level after
which no further indentation will be output.
r z&indentation amount can not be negativeN)r r8 r r r )r
num_spaces tab_widthlimitr& s r
set_indentzjson_options.set_indentw s:
O q5 EqI I ) !r c | j S )z:The method used to sort dictionary keys when encoding JSON)r r s r r zjson_options.sort_keys s r c |s t | _ y t | r|| _ y |t v r|| _ y |t v rt | | _ y |r t
| _ y t
d|z )Nz Not a valid sorting method: %r) SORT_NONEr callablesorting_methodssorting_method_aliasesr r8 )r methods r r zjson_options.sort_keys sZ 'DO
f
$DO
& $DO
-
- 4V >r c j | j t k( r| j j d S t S )z3The numeric value NaN, either a float or a decimal.rx )r r r r@ rm r s r rm zjson_options.nan s, ??n ,''66u= =Jr c j | j t k( r| j j d S t S )z8The numeric value Infinity, either a float or a decimal.ry )r r r r@ rn r s r rn zjson_options.inf s, ??n ,''66zB BJr c j | j t k( r| j j d S t S )z9The numeric value -Infinity, either a float or a decimal.rz )r r r r@ r r s r r zjson_options.neginf s, ??n ,''66{C CMr c t |t r
|dk rd}nd}t |t r,|j d s|j d r
|d }|dd }| j rmt |t r| j
t k( r3| j j | }|dk( r|j }no|dk( r|dk( r| j }nWd|cxk rdk rn nt | }|dk( r8|dz }n1t | }|t k( st | |k7 rD| j
t k7 r1| j j | }|dk( r|j }n|dk( r|dz }n| j || }| j |dd |d d k rd
nd z | }|t k( s||k( r~| j
t k7 rk| j || }nXt |t r |}|dk( rA|dk( r
| j }n/|dz }n) t | }|dk( r|dk( r
| j }n|dz } t |t r| j$ r
t' || }|S # t $ r | j" }Y Bw xY w)
zMakes an integer value according to the current options.
First argument should be a string representation of the number,
or an integer.
Returns a number value, which could be an int, float, or decimal.
r r1 r0 r
NlI5 l I5 rw 5r r, r )r> r rD r r r r r r@ copy_negater$ rB rn r
make_float make_decimalr8 rm r r )r rY rR r r& r s r make_intzjson_options.make_int s7 dC ax a ||C ALL$5tabE !S!??n4 ,,;;A>As{ MMO!V **A%=o= aAs{R aASCFaKT__ 5T 0 0 ? ? B 3; !
A ROOAt,__QsVaesls%LdSHRT__ -L ))!T2A
3
As{6 **AGA
F 3;Av . .R a $"2"2-8A
HH
s I I,+I,c P | j t k( r| j || S |j d s|j d r |d }|dd }nt |t
r
|dk rd}nd} | j j | }|dk( r|j }|S # t j $ r | j j d }Y |S t j $ rB |dk( r | j j d }Y |S | j j d }Y |S w xY w) z0Converts a string into a decimal or float value.r1 r0 r r
Nrx rz ry ) r r r, r r> r r r@ r+ r9 InvalidOperationr: r rY rR r[ s r r- zjson_options.make_decimal
s" ??l *??1d+ + << S 1Q4D!"A
c
"ax $$$33A6A s{MMO '' ;$$33E:A Ds{((77 D ((77
C Ds .B .D%2D%D%$D%c B t r%| j t k( r| j || S |j d s|j d r |d }|dd }nt |t r
|dk rd}nd} t | }|dk( r|dz }|S # t $ r
t }Y |S w xY w)z0Converts a string into a float or decimal value.r1 r0 r r
Nrw )
r9 r r r- r r> r rB r8 rm r1 s r r, zjson_options.make_float4
s t.8$$Q- - << S 1Q4D!"A
c
"ax aA s{R A s 4 B B B c | j S )z=The radix to be used for numbers with leading zeros. 8 or 10r r s r r z json_options.leading_zero_radixK
s '''r c t |t r t | }|dvr t d || _ y # t $ r1 |j }|dk( s
|dk( s|dk( rd}n |dk( s|dk( rd}Y Pw xY w)
Nr^ oct8r r9 decr2 r r2 z.Radix must either be 8 (octal) or 10 (decimal))r> rD r r8 r} r )r radixs r r z json_options.leading_zero_radixP
s eS !
E
MN N#(
G#u~# Ei'5E> E
s 4 7A.-A.c & ddd| j S )Nr^ r9 r9 r4 r s r leading_zero_radix_as_wordz'json_options.leading_zero_radix_as_word_
s *4+C+CDDr c J | j D ] }| j |d y )Nr[ )warn_behaviorsrr rm s r r z json_options.suppress_warningsc
s' '' -D dG , -r c L | j j | j S )zVReturns the set of all behaviors that are not forbidden (i.e., are allowed or warned).)allow_behaviorsunionr> r s r allow_or_warn_behaviorsz$json_options.allow_or_warn_behaviorsg
s! ##))$*=*=>>r c | j S r ) _strictnessr s r r zjson_options.strictnessl
s r c j |t k( r t | _ | j n|t k( s|du rct | _ d| _ | j | j
| j | j | j n|t k( s|du rst | _ | j | j
| j | j d| _
| j | j nt d|z | j! y)zPChanges whether the options should be re-configured for strict JSON conformance.TFr z Unknown strictness options %rN)r rD set_all_warnSTRICTNESS_STRICTr set_all_forbidwarn_duplicate_keyswarn_zero_bytewarn_bomwarn_non_portableSTRICTNESS_TOLERANT
set_all_allowwarn_leading_zerosr allow_non_portabler8 allow_any_type_at_start)r r s r r zjson_options.strictnessp
s _ $ .D
(
(FdN 0D $D ! $ $ & ! MMO " " $
*
*fo 2D $ $ & ! # # %&'D # MMO # # % r rc rg r r r r r
r r r r r r r! r$ rm rn r r r. r- r, r r< r rB r r r r r r : s K tV,TJl=$~wr
%$ "* H H $ $ # #
$3H CJ8. ( ( ) ) E E- ? ? ' 'r r ) metaclassc n e Zd ZdZdZddddddd d
d Zdd ddddd d
d
dd
ZddddddddZddiZdZ dZ
d Z e d Z
d Zd Zd Zd ZdDd"Zd# Zd$ Zd% Zd& Zd' Zd( Zd) Zd* Zd+ Zd, Z d- Z d. Z dEd/Z d0 Z d1 Z!d2 Z"d3 Z#d4 Z$dFd5Z%dGd6Z&d7 Z'd8 Z(d9 Z)dDd:Z*d; Z+d< Z,d= Z-d> Z.d? Z/d@ Z0dDdAZ1dB Z2dC Z3y!)HJSONa^ An encoder/decoder for JSON data streams.
Usually you will call the encode() or decode() methods. The other
methods are for lower-level processing.
Whether the JSON parser runs in strict mode (which enforces exact
compliance with the JSON spec) or the more forgiving non-string mode
can be affected by setting the 'strict' argument in the object's
initialization; or by assigning True or False to the 'strict'
property of the object.
You can also adjust a finer-grained control over strictness by
allowing or forbidding specific behaviors. You can get a list of
all the available behaviors by accessing the 'behaviors' property.
Likewise the 'allowed_behaviors' and 'forbidden_behaviors' list which
behaviors will be allowed and which will not. Call the allow()
or forbid() methods to adjust these.
z"'r /r r
r r )r rV r rQ r[ r& rr r )
r r r rQ r[ r& rY r r` r, z\nz\tz\bz\rz\fz\"z\\)r
r rW r rX r r z\/z3{}[]"\,:0123456789.-+abcdefghijklmnopqrstuvwxyz
)
decode_number decode_float
decode_object decode_array
decode_string encode_value encode_dictencode_dict_keyencode_sequence encode_bytesencode_defaultc ddl }|j }| j D ]1 }||v r| j ||| ||= | j |d 3 d|v r |d | _ nt di || _ t
dd D cg c]I }d|cxk xr dk nc xr5 t | | j vxr |j t | dvK c}| _
yc c}w ) a Creates a JSON encoder/decoder object.
You may pass encoding and decoding options either by passing
an argument named 'json_options' with an instance of a
json_options class; or with individual keyword/values that will
be used to initialize a new json_options object.
You can also set hooks by using keyword arguments using the
hook name; e.g., encode_dict=my_hook_func.
r Nr r r r ) r! r all_hook_namesset_hook_optionsr r r
_rev_escapesr" _asciiencodable)r r r! hooknamer s r r z
JSON.__init__
s ++ .H6!
hx(898$
h- . V # "> 2DM ( 26 2DM 1c]
!McM
MAd / //
M ((Q04LL
M
s ACc | j S )z{The optional behaviors used, e.g., the JSON conformance
strictness. Returns an instance of json_options.
)rl r s r r z JSON.options r r c ( | j |d y)z:Unsets a hook callback, as previously set with set_hook().N)rk r ro s r
clear_hookzJSON.clear_hook s
h%r c H | j D ] }| j | y)z=Unsets all hook callbacks, as previously set with set_hook().N)rj rs rr s r clear_all_hookszJSON.clear_all_hooks s# ++ &H OOH % &r c || j v r1|dz }|dk7 rt | st d|z t | || yt d|z )a Sets a user-defined callback function used during encoding or decoding.
The 'hookname' argument must be a string containing the name of
one of the available hooks, listed below.
The 'function' argument must either be None, which disables the hook,
or a callable function. Hooks do not stack, if you set a hook it will
undo any previously set hook.
Netsted values. When decoding JSON that has nested objects or
arrays, the decoding hooks will be called once for every
corresponding value, even if nested. Generally the decoding
hooks will be called from the inner-most value outward, and
then left to right.
Skipping. Any hook function may raise a JSONSkipHook exception
if it does not wish to handle the particular invocation. This
will have the effect of skipping the hook for that particular
value, as if the hook was net set.
AVAILABLE HOOKS:
* decode_string
Called for every JSON string literal with the
Python-equivalent string value as an argument. Expects to
get a Python object in return.
* decode_float:
Called for every JSON number that looks like a float (has
a "."). The string representation of the number is passed
as an argument. Expects to get a Python object in return.
* decode_number:
Called for every JSON number. The string representation of
the number is passed as an argument. Expects to get a
Python object in return. NOTE: If the number looks like a
float and the 'decode_float' hook is set, then this hook
will not be called.
* decode_array:
Called for every JSON array. A Python list is passed as
the argument, and expects to get a Python object back.
NOTE: this hook will get called for every array, even
for nested arrays.
* decode_object:
Called for every JSON object. A Python dictionary is passed
as the argument, and expects to get a Python object back.
NOTE: this hook will get called for every object, even
for nested objects.
* encode_value:
Called for every Python object which is to be encoded into JSON.
* encode_dict:
Called for every Python dictionary or anything that looks
like a dictionary.
* encode_dict_key:
Called for every dictionary key.
* encode_sequence:
Called for every Python sequence-like object that is not a
dictionary or string. This includes lists and tuples.
* encode_bytes:
Called for every Python bytes or bytearray type; or for
any memoryview with a byte ('B') item type. (Python 3 only)
* encode_default:
Called for any Python type which can not otherwise be converted
into JSON, even after applying any other encoding hooks.
_hookNz+Hook %r must be None or a callable functionzUnknown hook name %r)rj r r8 rp )r ro r6 atts r rk z
JSON.set_hook s` V t** *W$C4 (: AHL
D#x ( 3h >? ?r c X |r|| j vryt | |dz }t | S )NFrw )rj rk r )r r hooks r has_hookz
JSON.has_hookl s0 IT-@-@ @tY 01~ r Nc ddl }|| j vrt d|z t | |dz }t | st d| ||g|i |}|S # t $ r t $ r[} |j }
|j d rt } nt } t | t rd} nd} | ||
|g||| d }
|
| d} ~ ww xY w)
zWrapper function to invoke a user-supplied hook function.
This will capture any exceptions raised by the hook and do something
appropriate with it.
r NzNo such hook %rrw zHook is not callable: encode_r r r) )r| rj rl rk r rC r r/ r r r r r> r )r r input_objectr< r r r| rz rvalr( r ex_classr r1 s r call_hookzJSON.call_hookr s D / / / !2Y!>? ?tY 01~$ @A A " 6t6v6D2 1 "#s||~H##I...# 12""
"!
F c !+ "s
A C*AC Cc | j j s|dv S t |t s t | }|dv ryddl}|j | dk( S )zDetermines if the given character is considered as white space.
Note that Javscript is much more permissive on what it considers
to be whitespace than does JSON.
Ref. ECMAScript section 7.2
r_ rh Tr Nri )r r r> rD r! r" )r r r! s r iswsz JSON.isws sR ||.. > ! a%FM! ''*d2 2r c 0 |dk( s|dk( ry|dk( s|dk( ryy)zqDetermines if the given character is considered a line terminator.
Ref. ECMAScript section 7.3
r r
Tu
u
Fr r@ s r
islinetermzJSON.islineterm s'
9T =AMr c |j }|j d |j }| j | |j r |j d|j |S |j d|z |j |S )zJTry to recover after a syntax error by locating the next "known" position.c 8 | dv xs t j | S )Nz ,:[]{}"';)r rn rW s r r' z%JSON.recover_parser.. s \ 1 SW5P5PQR5S r z.Could not recover parsing after previous errorr* z%Recovering parsing after character %r)r rX r? ra r r; r< )r stater stopchars r recover_parserzJSON.recover_parser s ii
ST88: E :: OO@3<<
OO7(B
r c |j }|j }|j }|r|dk7 r|j d|| y|j xj
dz
c_ y)zIntermediate-level decoder for ECMAScript 'null' keyword.
Takes a string and a starting index, and returns a Python
None object and the index of the next unparsed character.
rP zExpected a 'null' keyword'r* r
N)r r< ro r7 r r r r r start_positionr s r decode_nullzJSON.decode_null sb ii
!R6\ 92 W
KK ! !Q & !r c & |j d y)z,Produces the ECMAScript 'undefined' keyword.rg Nr r r s r encode_undefinedzJSON.encode_undefined s
[!r c & |j d y)z!Produces the JSON 'null' keyword.rP Nr r s r encode_nullzJSON.encode_null s
V r c |j }|j }|j }|r|dvr|j d|| |dk( S |j xj
dz
c_ |dk( S )zIntermediate-level decode for JSON boolean literals.
Takes a string and a starting index, and returns a Python bool
(True or False) and the index of the next unparsed character.
)rQ rR z%Expected a 'true' or 'false' keyword'r* r
rQ )r r< ro r7 r r r s r decode_booleanzJSON.decode_boolean sv ii
!R 00 7n
V|
KK ! !Q & !V|r c J |j t | rd yd y)z7Encodes the Python boolean into a JSON Boolean literal.rQ rR N)r r )r bvalr s r encode_booleanzJSON.encode_boolean s
tDzV7w7r c |j }| j | |j }| j d s| j d r|j }|r|dv r|j |j
d }d|v r| j d rd}n| j d rd}nd}|r' | j ||| }|j |S |j d} d }
d
} d
} |j }|rX|d v rT|d k( r| d
z } n|dk( rd} |
dz
}
|j | j | d kD rd} |j }|r|d v rT|
dkD s| r(|j! | j" j$ d| | r|j' d| |sI|j' d| | j) | | j* xj, dz
c_ t S |j/ s|dv r |j1 d }
|
dk( r]|j! | j" j2 d| |j* xj4 dz
c_ | j" j6 S |
dk( rx|j! | j" j2 d| |j* xj8 dz
c_ | d k r| j" j: S | j" j< S |j' d|
| t S |dk( r|j d dv r|j? d }|j1 t@ jB }|j! | j" jD d ||z | tG | d k( r*|j' d | | j) | t S t@ jI | }|jK || | |j" jM || tN }|S |dk( r|j d d!v r|j? d }|j1 t@ jP }|j! | j" jR d"||z | tG | d k( r*|j' d#| | j) | t S t@ jU | }|jK || | |j" jM || tV }|S |dk( r|j d d$v r|j? d }|j1 t@ jX }|j! | j" jZ d%||z | tG | d k( r*|j' d&| | j) | t S t@ j] | }|jK || | |j" jM || t^ }|S |j1 d' }tG | }|d k( r|j' d(| d
}g }g }g }d}d }d
}d
}d)} ta | D ] \ } }|dk( r7| d)k7 r-|j' d*|| | j) | t c S d+} d}B|d,v r7| d-k( r-|j' d*|| | j) | t c S d-} d}}|d v r7| d-k7 s|r-|j' d*|| | j) | t c S |}| d)k( r|jc | | d+k( r|jc | | d-k( s|jc | d.je | } d.je | } d.je | } |xs | }!| s-| s+|j' d*|| | j) | t S |r-| s+|j! | j" jf d/|| d} |r-| s+|j' d0|| | j) | t S | s,|j! | j" jh d1|| d} ntG | dkD r| d dk( rd}| j" jj r*|j! | j" jl d2|| nV| j" jn r@|j! | j" jl d3| j" jp z || tG | | z js dd4 ju }|ri|!rg| j" jv d5k( rN t@ jU | }|jK || | |j" jM || tz }|S | r t} | }"|d k( r|" }"nd }"|sO|"d k\ rJt} | }|"d k7 r|d8|"z z }|jK || | |j" jM || }|S |"t~ k s|"t kD s |t kD r |j" j || }n |j" j || }|j || | |S # t $ r Y t $ r"}|j | t }Y d}~ d}~ww xY w# tx $ r> |j' d6|| | j) | | j" j6 cY S w xY w# tx $ r. |j' d7|| | j) | t cY S w xY w# tx $ r2}|j' d9|j z || t }Y d}~|S d}~ww xY w):a Intermediate-level decoder for JSON numeric literals.
Takes a string and a starting index, and returns a Python
suitable numeric type and the index of the next unparsed character.
The returned numeric type can be either of a Python int,
long, or float. In addition some special non-numbers may
also be returned such as nan, inf, and neginf (technically
which are Python floats, but have no numeric value.)
Ref. ECMAScript section 8.5.
r\ r] z
-+0123456789.z$-+0123456789abcdefABCDEFNaNInfinity.r Nr* r
r Fz+-r1 rw r0 Tz3Numbers may only have a single "-" as a sign prefixz>Spaces may not appear between a +/- number sign and the digitsz Missing numeric value after signrp c . | j xs | dv S )Nrp rt rW s r r' z$JSON.decode_number..N s (@qDy r rx z+NaN literals are not allowed in strict JSONry z0Infinity literals are not allowed in strict JSONz Unknown numeric value keywordr, )r Xr. z3Hexadecimal literals are not allowed in strict JSONz Hexadecimal number is invalid)rR r< r* )oOz-Octal literals are not allowed in strict JSONzOctal number is invalid)rQ r z.Binary literals are not allowed in strict JSONzBinary number is invalidc
| dv S )Nz0123456789.+-eEr rW s r r' z$JSON.decode_number.. s A1B,B r zMissing numeric valueunitsz
Bad numberfractioneEexponentr z@Bad number, decimal point must be followed by at least one digitz Bad number, exponent is missingz@Bad number, decimal point must be preceded by at least one digitz(Numbers may not have extra leading zerosz6Numbers may not have leading zeros; interpreting as %sr r z#Bad number, not a valid octal valuezBad number, bad exponentr2 zBad number, %s)Fr ra r< r{ r? r rl r r$ r r. r, rg r) rU skipws_nocommentsr+ r r r7 r r r rq rk r r rm r r rn re r rX r r r rX r. r r[ r r r r] r r r r r r r r is_forbid_leading_zerosr is_warn_leading_zerosr< r r r r8 r r float_minexp float_maxexpfloat_sigdigitsr- r, rT r )#r r r r r nbrr r r( rR
sign_count
sign_saw_plus sign_saw_wsr r r ivalr& numberimaxhas_leading_zero units_digitsfraction_digitsexponent_digitsesignrM saw_decimal_point saw_exponentin_partr units_s
fraction_s
exponent_s
is_integerr s# r r\ zJSON.decode_number s+ ii E == )T]]>-J
AQ/)!!#&&'ST#:$--"? .I]]?3 /I $I # "nnYnn U 002 "
$$&
HHJAICxbyc $
!OJ HHJ%%e,q0 "
A AI >] OO ..E'
P'
2^
& JJ % % * %
YY[AI @ABU{LL,,A +
$$)$||'''z!LL,,F +
**a/*!8 <<... <<+++ 3R. ! ! #X388A;*4ZZ]F\\'"6"67F OO ((E'
6{a 3n ! ##E* %%f-D & &t$ & P
&&tTAR&SAH
#X388A;*4ZZ]F\\'"8"89F OO **?'
6{a !:^ T##E* ''/D & &t$ & P
&&tTAT&UAH
#X388A;*4ZZ]F\\'"9"9:F OO ++@'
6{a !;n U##E* ((0D & &t$ & P
&&tTAU&VAH \\"BCFv;Dqy !8> R $ L O OEI % L G!&)
218 ') (( v(W ++E2 (( (G(,%$Y *, (( v(W ++E2 (( (G#'L$Y *, (( v(W ++E2 (( E ')$++A. J.'..q1 J.'..q19
2: ggl+G 1J 1J 0 ?<@J: v O##E* LL77V + !
J 5v ! ##E* LL66V + W !gajC&7#' <<77OO 22B !/ $ \\77OO 22P ,,AAB !/ $ Wz 1 : :3 D J J LMI J4<<3R3RVW3W ,"//8D **4d^*TMM**$.G + % ":H C< (yH %Q 7|q=B(N*D**4d^*TMM**46& H!T </#l2$6 !MM 6 6vt D !MM 4 4VT B ,,QTN,SHQ ( $ ( ,,S1 '(^ " ,$$= !/ %
''. <<+++,$ " %$$2F^ % ''.$$ %< " "$$(3;;6 % "A H"s\ 4i 4j k ,Al j "j *jj Akk4ll m 'm mc t |t r$|j r t d| |j }t |t
r |j
|j yt |t r|j
t | yt |t j r|j r|j
d y|j r4|j r|j
d y|j
d yt | j }d|vr d|vr|dz }|j
| y|t u r|j
d y|t" u r|j
d y|t$ u r|j
d yt |t& rt) | j }d |v rd
|v s |t$ k( r|j
d yd |v s|t" u r|j
d yd |v s|t u r|j
d y|j
t) | yt+ d t- | )
aG Encodes a Python numeric type into a JSON numeric literal.
The special non-numeric values of float('nan'), float('inf')
and float('-inf') are translated into appropriate JSON
literals.
Note that Python complex types are not handled, as there is no
ECMAScript equivalent type.
zBCan not encode a complex number that has a non-zero imaginary partNrx rz ry r3 r z.0rn r1 rm zAencode_number expected an integral, float, or decimal number type)r> compleximagr realr r r r rD r9 r< r r r r} rm rn r rB r rC r )r r& r rY reprns r
encode_numberzJSON.encode_numberG s a !vv%X A a " LL ) a LLQ a )xxz U#
;;=LL-
LL,
FLLNa d$||d
|j* } d}|j1 t$ j@ | }|rL|j |k7 r)|j
d%|z ||z ||d
|j* } n|j ||z |z }|s%|j
d&|||d
|j* } d'}n;|r$tC | |k7 r|j
d(|||d
t$ jE | }|d)kD r |j
d*||z |z ||d
d'}|r0t9 | } t$ j' || } || d}d} n|d k rN|dk( r6|j | j j4 d||d
|j* } |t9 | nud+|cxk rd,k r n n t9 | }|jG } nJd
|cxk rd k r.n n+|j
d-||d
|j* } |d n |t$ j; | n|j | j jH d.d|
z ||d
|j* } ||
|j nt! |
d/k rt! |
dk( r@|j | j j4 d|j |d
|j* } | jK |
rU|
s:|j
d0d1t! |
z |j |d
|j* } d}
||
|j n|r ||
|j n|j
d2d1t! |
z |j |d
|j* } |j nyd+t! |
cxk rd,k r.n n+|j# }|j jG } n7|j1 fd3 }|s ||
|j n || | s| s|r!|j
d| |d
|d d}d} | s |j
d4|j |d
|j* rt S d jM | }|jO ||5 | jQ d6 r | jS d6||5 }|S |S # t( $ r* |j
d ||f| |d
|j* } d}Y kw xY w# t( $ r* |j
d ||f| |d
|j* } d}Y w xY w# tT $ r Y |S tV $ r"}|jY | t }Y d}~|S d}~ww xY w)7zIntermediate-level decoder for JSON string literals.
Takes a string and a starting index, and returns a Python
string (or unicode string) and the index of the next unparsed
character.
r r z>String literals must use double quotation marks in strict JSONz&String literal must be properly quotedNFz String literal is not terminatedStringr r r r z Illegal Unicode surrogate pairr< r r u �r. z\uz:High unicode surrogate must be followed by a low surrogateTr z&Escape in string literal is incompleter, 3r rv r zBZero-byte character (U+0000) in string may not be universally safez;JSON does not allow octal character escapes other than "\0"ri ur r {}z)JSON strings do not allow \u{...} escapesr z*JSON strings may not use the \x hex-escapez/Unicode escape sequence is missing closing '%s'z.numeric character escape sequence is truncatedr z.escape sequence has too few hexadecimal digitsi z$Unicode codepoint is beyond U+10FFFFr r z;Low unicode surrogate must be proceeded by a high surrogatez0String escape code is not allowed in strict JSONr zALine terminator characters must be escaped inside string literalsr z>Control characters must be escaped inside JSON string literalsc 6 | t j vxr | k7 S r r )r quotes r r' z$JSON.decode_string.. s aw'B'B B QqEz r z6String literal is not terminated with a quotation markr* r` )-r ra r? r+ r r r7 rg r< rU is_forbid_js_string_escapes
_escapes_json _escapes_js is_forbid_control_char_in_stringr r r r# r r r8 r rL r[ rk r r r r
r r r rX r r r r r r rL r{ r r r. r, ) r r r string_positionescapes ccallowedr _appendhigh_surrogatehighsur_positionhad_lineterm_errorsaw_final_quoter r
low_surrogateucescape_position maxdigitsr r&
esc_opener
esc_closer esc_sequencerd chunkrY r( r s @r r` zJSON.decode_string s ii E
C<
c\ OO 22P
E F ,,
<< 3 3((G&&G EEE -- # !+zz 6#2 $ !
A SV-v-$'GGIM
& $ > > *M BK%)N'+$ [[^u,$$T!1'6 ( % #("3"3KH%%)N'+$Ez
"&d"%,,
HHJ$$@!0'6 ( % #("3"3K ++A. a3$% $% \\'*@*@9\ UF ,,V4AAv LL 2 2 ` 6M%4+:$,
( LL 6 6 Z 6M%4+:$,
( #("3"3K3w A 3 3A 67'\HHJGAJ'#XcHHJ!%J!#JCx 88:, HHJ &# -J),J(,I !OO $ E E L)8/>(0 , )*I LL : : I%4+:$, ( ',&7&7 $% \\'*>*>\ SF! 88:3 ! , , Q",!- *V 3)8/>(0
- +0*;*;K HHJ#-#6#CL! (( L (%4+:$, ) ',&7&7 $* $V )A ! , , P ,)8/>(0 - %,$6$6v$> 8+ (( B & /* <%4+:$, ) %+ %(+I
*!(!B!B .
" B )-+/("S $> !OO $ 6 6 d)8/>(0 , +0*;*;K I/ 966), %* ,;+?+?+A( 966 (( Y%4+:$, ) ',&7&7 ) 3 3I >? OO 99J q!0'6 (
$ #("3"3KAJHHJQ4 q6Q;OO ..\!$ '6 ( $ #("3"3K??1%- (( _ $s1v -%(\\+:$, ) ',&7&7 -1*AJHHJ AJHHJ$$X 3q6)!$ '6 ( % #("3"3KHHJ3q6+V+!$#&<<#4#4#6 Q AJHHJEN "+D L) .
H !N # H .
GGFO
!!!o!> == )
NN?ANP qg & & (( < +] ;%5+:$, ) ',&7&7 % &J * * ! , , @!/ ?)9/>(0 - +0*;*;K!)B *R
$$S)
sB b#
c d #/cc/d d ee#e ec " ddl }ddl}ddl}| j j t ||j rfd}n(r$t |t s|j }d}nd}g }|j d | j }| j } | j }
|j j } |j } d}
t | }|
|k r|r |||
}n||
}t! | }|dk r|
| r|t | t" rl| r|| v sf|
}|
dz
}
|
|k r;|r |||
}n||
}t! | }|dk r|
| r | r|| v s|
dz
}
nn|
|k r;|j t |||
n||v r|j || |
dz
}
n|dk r|j d|z |
dz
}
nd |cxk rd
k rn nd }|j$ d k( rhd |cxk rd
k r]n nZ|
dz |k rR|}|
dz
}
|r |||
}n||
}t! | }|
dz
}
d|cxk rd
k r n n|}|j d||fz d}|sd|z }t' d| |d k r|| r|| v rd}n,|j) | dv rd}nt+ | r | | }n| }|r.|| v r|j | | n&|j d|z n|j | |
dz
}
n| r|| v rd}n,|j) | dv rd}nt+ | r | | }n| }|r8t, j/ | D ] }|j dt! | z ! n|j | |
dz
}
|
|k r|j d |j dj1 | y)z3Encodes a Python string into a JSON string literal.r Nc f | j }r!t |t s|j S |S r )datar> rD r )r r py2strencs r tocharz"JSON.encode_string..tochar s, VV ZC%8 99Y// Ir r r r
r r r r Fr r r z \u%04x\u%04xTr z7can not include or escape a Unicode surrogate characterr r )r! r| r r r r> r rD r r rm _optional_rev_escapesrn r r r r r r r r" r r r r )r rY r r! r| r r r revesc optrevescasciiencodabler
encunicoder r r cordrK handled_raw_surrogates
hsurrogate
lsurrogatecnamedoesc surrogater s @r
encode_stringzJSON.encode_string s
LL00 a// 0
z!S 1#AF F
c"".. --
99
..
1v$h1Q4LaDq6Ds
"4( z40&1
+=
Q$h "1Q4L aD q6D s
*4 0!.1
3EQ $h
c!Aa&k*f
fQi(Q
i$ ./Q4)6) */&NNf, $0&0Q$ "&JFA "1Q4L aD q6DFA //%)
oZ8P&PQ15.- $tOE)QSX Q-%7 E ))!,0HH E j) &qME &EI~
il3
i$&67MM!$Q !Q-%7 E ))!,0HH E j) &qME &E%,%F%Fq%I B
i#i.&@AB MM!$QS $hV
c
RWWV_%r c |j }| j | |j }d}|j }|s|j d| |S |dk( r#d}|j
xj dz
c_ |S |dk( r#d}|j
xj dz
c_ |S |dk( r#d }|j
xj dz
c_ |S |d
k( rP|j | j j d || t }|j
xj dz
c_ |S |d k( s|d
k( r|j | j j d|z || | j d r | j d|| }|S | j d r | j d|| }|S |d k( r7|j
xj& dz
c_ |j j( }|S |j
xj* dz
c_ |j j, }|S |r|t. j0 v r|j3 d|| |j | j j4 d|| |j
xj6 dz
c_ | j9 | }|S |j d|| t }|j
xj6 dz
c_ |S # t $ r Y =t" $ r!}|j% | t cY d}~S d}~ww xY w# t $ r Y ut" $ r!}|j% | t cY d}~S d}~ww xY w)z Decodes an identifier/keyword.NzExpected an identifierr* rP r
rQ TrR Frg z2Strict JSON does not allow the 'undefined' keywordrx ry z*%s literals are not allowed in strict JSONr] r\ z(Identifier is a JavaScript reserved wordz5JSON does not allow identifiers to be used as stringszUnknown identifier) r ra r< ro r7 r r r r+ r r rg r r r{ r r r. r, r rm r rn r r r9 r r decode_javascript_identifier) r r identifier_as_stringr r r r r r( s r decode_identifierzJSON.decode_identifier sA ii E
! 5 OR
Q 6\C KK ! !Q & !L
K 6\C KK ! !Q & !F
E 7]C KK ! !Q & !@
;
OO --D'
C KK & &! + &n
m 5[B* , OO ((T)HHQK $I[[^t+$$?'5 ) % ::e$))%0 $I GGI# **& Y . -!
A% r c b |j j | j j S )z+Skips whitespace (will not allow comments).)r ra r is_forbid_unicode_whitespacer s r r zJSON.skipws_nocomments s$ yy DLL$M$M MNNr c |j }| j j }|j s_|j d }|dk( s|dk( r| j | n$|j
| r|j | ny|j s^yy)aZ Skips all whitespace, including comments and unicode whitespace
Takes a string and a starting index, and returns the index of the
next non-whitespace character.
If the 'skip_comments' behavior is True and not running in
strict JSON mode, then comments will be skipped over just like
whitespace.
r. r r N)r r r r rL r rC ra )r r r r r s r ra z JSON.skipws sr iiLL333** AADyAI!!%(5!
5! **r c |j ry|j }| j | |j }|dvr|j d y|j
}|j
|dk( rd}d}g }n4d}d}|j j t k( rt r t }ni }d }| j | |j } | |k( r|j
d}
nd} d}
|
s|j s|j s| j | |j } | d
k( rn`| d k( r| s|r|j d |d
ni|j | j j d|d |j t |j r |j xj" dz
c_ |j
d} | |k( rk| sU|r*|j | j j$ d|d
n)|j | j j$ d|d |j
d}
nV| dv r$|rd
} nd} |j d|| fz || d}
n.|j rn |j
}
|r| j' |d }n| j' |d }|t( u r| j+ | }|dvr|j rn| r |rd
} nd} |j d|
|| d} | j | |j rn|rJd}|}|
}t, j/ | sWt, j1 | r+|j | j j2 d||d
n|j d||d
d}|j } | dk7 r|j d |
|d
|j
| j | | j' | }| j | |s||v r+|j | j j4 d |||d
|d
k( r*|j | j j6 d ||d
|||< |dz
}n|j | |dz
}|
s|j s|j s|j ra|r0t9 |j j: | |j _ n/t9 |j j< | |j _ |j r|S |
s+|r|j d |d
n|j d |d |rI|j xj> dz
c_ | jA d! r | jC d!||" }|S |S |j xjJ dz
c_% | jA d# r | jC d#||" }|S |S # tD $ r Y |S tF $ r"}|jI | t }Y d}~|S d}~ww xY w# tD $ r Y |S tF $ r"}|jI | t }Y d}~|S d}~ww xY w)$zOIntermediate-level JSON decoder for composite literal types (array and object).N{[z)Composite data must start with "[" or "{"[F]Tr r r r z/Can not omit elements of an object (dictionary)Objectr z(Can not omit elements of an array (list)Arrayr
zJStrict JSON does not allow a final comma in an object (dictionary) literalzCStrict JSON does not allow a final comma in an array (list) literalz]}z Expected a '%c' but saw '%c'r r z#Values must be separated by a commar z=JSON only permits string literals as object properties (keys)zIObject properties (keys) must be string literals, numbers, or identifiersz/Missing value for object property, expected ":"z Object contains duplicate keyz=Using an empty string "" as an object key may not be portablez-Object literal (dictionary) is not terminatedz&Array literal (list) is not terminatedr^ r* r_ )&r r ra r? r7 r< rU r r
SORT_PRESERVE _OrderedDictr r+ r r rg r r r decodeobj syntax_errorr r r r r r rD rO r r r r{ r r r. r, r )r r r openerr isdictcloserr num_itemsr done saw_valuer value_positionr recover_c skip_itemr key_positionr r( s r decode_compositezJSON.decode_composite+ s9 ii E H I
S=FFCFF}}&&-7L"n E HHJ ; HHJD ID3::e6G6G E"HHJ7#X$! ! , , Q/=(0 - "OO $ C C J/=(/ , JJy 1 ${{ % : :a ? :HHJ %I &[$! !OO $ ; ; l/=(0 , "OO $ ; ; e/=(/ , HHJ D$Y ( '$$6&!D'5 % %
D$$ "% ..T.JC ..U.KC,& $ 3 3E :I + $$ ( '$$=!/'5 % % ! E"$$ %I C#1L"//4"//4 !OO $ ; ; _)5/=(0 , " , , k)5/=(0 - )-I
ACx (( M%3+9$, ) HHJKK& >>%0DKK&$ #: !OO $ ; ; ? #)5/=(0
, "9 !OO $ 9 9 _)5/=(0 , $(C!Q JJsO NIs 3::e6G6Gx ;;25KK33Y3 / 25KK22I2 . J C#1 $ ! <#1 # ! KK # #q ( #}}_-$ .. #.WC
s
KK " "a ' "}}^,$ .. ~.VC
s
$
! $((-#C
$ $
! $((-#C
$s< -W 6X XX"W??X X=X=X88X=c |S )a Convert a JavaScript identifier into a Python string object.
This method can be overriden by a subclass to redefine how JavaScript
identifiers are turned into Python objects. By default this just
converts them into strings.
r rm s r r z!JSON.decode_javascript_identifier s r c |j }d}| j | |j r|j d |j }|dv rN|xj
dz
c_ |j
| j | }|xj
dz c_ |S |r&|j | j j d || j v r| j | }|S |j s|dv r| j | }|S |j s|dv r| j! || }|S |j d |z |j# | j% | t& }|S # |xj
dz c_ w xY w)
a. Intermediate-level JSON decoder.
Takes a string and a starting index, and returns a two-tuple consting
of a Python object and the index of the next unparsed character.
If there is no value at all (empty string, etc), then None is
returned instead of a tuple.
NzUnexpected end of inputr r
z:JSON document must start with an object or array type onlyz.+-rp r z/Can not decode value starting with character %r)r ra r r7 r? r rG r r+ r r _string_quotesr` rE r\ rq r rU r r )r r r at_document_startr r r s r r zJSON.decodeobj& sw ii E :: 6 7 HHJ 9 OOq O
%((*++E21$(
% !LL22P D'''((/
U
((/
T ,,0D -
!RUV!VW
##E*"
) 1$s '!E5 5F c t | j }|j || |j s| j | |j s | j | |r`|j rT|j j |j _ |j j j |j _ t# dg d }|rH|r( ||j$ |j& |j S ||j$ |j& d S |j& D cg c] }|j( d v s| } }| r| d
|r ||j$ d|j S |j$ S # t $ r }|j | Y d}~5d}~wt $ rX}t dd|j j } ||# t $ r}|j | Y d}~nd}~ww xY wY d}~d}~ww xY wc c}w ) a Decodes a JSON-encoded string into a Python object.
The 'return_errors' parameter controls what happens if the
input JSON has errors in it.
* False: the first error will be raised as a Python
exception. If there are no errors then the corresponding
Python object will be returned.
* True: the return value is always a 2-tuple: (object, error_list)
)r r( Nz An unexpected failure occuredr )r r< json_results)objectr r r! r )r r r. r$ _JSON__sanity_check_start
_do_decoder r, r/ r r r< r r r r r rF r r r )
r ry r
return_errors return_statsr r( r1 result_typer s
r r z JSON.decodeS s T\\2 h/ % %e ,
.& EII05 0H0HEKK -&+ii&8&8&F&FEKK # ".2OP "599ellEKKHH"599ellDAA &+\\XcS\\EW5WcXFX Qi"599dEKK@@ yy C !
*$$S))
.(3 $ "YY / /
. c) .((--.-
.2 YsT E: -HH: G>F G>&"G9 G G0G+&G9+G00G99G>c d}|j j d }t | dk\ r|dd \ }}|| j v r |S t | dk s*t | dkD s t | dk st | dkD rs| j | sb| j | sQddl}|j t | }|j t | }|dvs|dvr|j d |S ) a Check that the document seems sane by looking at the first couple characters.
Check that the decoding seems sane. Per RFC 4627 section 3:
"Since the first two characters of a JSON text will
always be ASCII characters [RFC0020], ..."
[WAS removed from RFC 7158, but still valid via the grammar.]
This check is probably not necessary, but it allows us to
raise a suitably descriptive error rather than an obscure
syntax error later on.
Note that the RFC requirements of two ASCII characters seems
to be an incorrect statement as a JSON string literal may have
as it's first character any unicode character. Thus the first
two characters will always be ASCII, unless the first
character is a quotation mark. And in non-strict mode we can
also have a few other characters too.
Tr. Nrh r r )ri r r r z8The input is gibberish, is the Unicode encoding correct?)
r rL r r r r r! r" rD r- ) r r is_saner firstsecondr! catfirst catseconds r __sanity_check_startzJSON.__sanity_check_start s ( ""1% v;! "2AJME6+++. ) Z$&#e*t*;F d*c&kD.@ 99U+DIIf4E
' * 3 3CJ ?H + 4 4S[ AI '??9 U D (( V r c |j }| j | |j r|j d y|j j
r*t
j |j j
}nt }|5 | j |d |_
ddd |j s0| j | |j s|j d yyy# 1 sw Y FxY w)zThis is the internal function that does the JSON decoding.
Called by the decode() method, after it has performed any Unicode decoding, etc.
zNo value to decodeT)r Nz'Unexpected text after end of JSON value) r ra r r7 r r r9 rA r
r r r )r r r dec_ctxs r r zJSON._do_decode s
ii E :: 1 2}},,!..u}}/L/LM0
J NN5DN I
J $$ E"zz$$%NO " %
J
Js C""C+c F dd l }d}|d}|S |t u rd}|S t |t rd}|S t |t t
t f s t r t |t j rd}|S t |t st j | rd}|S t |t rd}|S t |t rXt |d rLt |j r7| j" j$ }|r|d
u st | r || rd }|S d }|S t |t& t t( t* f rd }|S t |d
st |d rt |d rd}|S t ||j rd}|S t ||j, rd}|S t ||j. rd}|S t ||j0 rd}|S t2 dk\ rt |t4 t6 f rd}|S t2 dk\ rt |t8 rd}|S t: t |t: rd}|S d}|S )Nr r rP rg r r r dict_asdictTr sequenceiterkeysr| keysdatetimedatetime timedeltar r}
memoryviewrH ) r3 rg r> r r rB r r9 r< rD r r r. tupler r r/ r r r rj r r4 r5 r6 _py_majorr} r~ r7 _enum)r r r3 r enc_nts r _classify_for_encodingzJSON._classify_for_encoding sN ;A` _ I
A\ [ T
"AX W c5' 2
3
38AP O S
!W%9%9#%>AL I #t$F C 3&C+ S[[) AAv~(62Bvc{$A4 1 #A0 / C$sI!>? , + j)]+V0D$ # C!2!23 C / C / C!3!34 a JsUI4F$G
a JsJ$?
"z#u'= r c b ddl }t | j }|d}nHt ||j r|}|j
}n#t j | }|s t d| | j j r;t | j j r | j j |_ n| j j dk( s |r |j
j dk( r d |_ nc|j
dk( r d |_ nK|r1|j
j j d rd
|_ n|j fd }||_ |# |j t j \ }}| j% || | j j& s|j) d
|j+ }
||
}|S |j |
\ }}|S # t" $ r } t d |j
z | d} ~ ww xY w# t, $ r} t d } | | d} ~ ww xY w)a Encodes the Python object into a JSON string representation.
This method will first attempt to encode an object by seeing
if it has a json_equivalent() method. If so than it will
call that method and then recursively attempt to encode
the object resulting from that call.
Next it will attempt to determine if the object is a native
type or acts like a squence or dictionary. If so it will
encode that object directly.
Finally, if no other strategy for encoding the object of that
type exists, it will call the encode_default() method. That
method currently raises an error, but it could be overridden
by subclasses to provide a hook for extending the types which
can be encoded.
r Nr+ Tasciic t | dk\ S )Nri r rW s r r' z JSON.encode..C s c!fn r z iso8859-1c t | dk\ S )Nr r@ rW s r r' z JSON.encode..E s c!fo r utfFc 6 | y# t $ r Y yw xY w)NFT)r )r enc_funcs r escape_unicode_hardwayz+JSON.encode..escape_unicode_hardwayP s( % % . $ #$s z3Output encoding %s is not sufficient to encode JSONr
z!a Unicode encoding error occurred)r r r r> r r r r r r r r r} r r rU json_syntax_characters UnicodeError
_do_encoder r r r )
r r r r r r rE outputncharsr( r r1 rD s
@r r z JSON.encode s & T\\* C
&"2"2
3CxxH&&x0C%? << & &8DLL4O4O+P(, (C(CE % ++t388>>#w. -E)[(,E) )44U; -2)
::% -C)
!$D,G,G!H
U#||,, LL F
&!$F!3
+
%ICHHT
" &
&()LM #%
&s0 "G( H ( H1H
H H.H))H.c | j | }| j d rD|} | j d| }||ur+|}| j | }||k7 r| j || yt |d r| j
|| }|ry|dk( r| j | y|dk( r3| j j s| j | yt d |dk( r| j || y|dk( r | j || y|d k( r| j! || y|d
k( r| j# || y|d k( r| j% || y|d k( r| j' || y|d
k( r| j) || y|dk( r| j+ || y| j- || y# t $ r Y w xY w# t $ r2} | j || n# t $ r}||d}~ww xY wY d}~yd}~ww xY w)zInternal encode function.ra Njson_equivalentrP rg z.strict JSON does not permit "undefined" valuesr r r rH r3 r4 r5 r6 )r< r{ r r rH r encode_equivalentr r is_forbid_undefined_valuesr r r r try_encode_defaultr/ r encode_enumencode_datetime encode_date encode_timeencode_timedeltaencode_composite) r r r obj_classificationorig_objprev_clssuccesserr1err2s r rH zJSON._do_encodev s ! 8 8 = == (H
nn^S9 ("-%)%@%@%E"%1OOC/ 3) *,,S%8G ' U #
;
.<<::%%e,%&VWW
6
) U +
8
+
)""3. 8
+ sE *
6
) S% (
:
- e ,
6
) S% (
6
) S% (
;
. ! !#u -
! !#u -e
8 #
))++C7 ) D() 8
)sG F+ 5F; + F87F8; G6GG1 G)!G$$G))G11G6c | j j }|dk( r | j t | | y|dk( r | j |j
| y| j |j | y)z%Encode a Python Enum value into JSON.r r N)r r r rD rH r r )r r r eass r rP zJSON.encode_enum sY ll)) '> s3x /
G^ OOCIIu - sxx /r c | j j }|r|dk( rd}| j |j | | y )Nr z%Y-%m-%d)r r r strftime)r dtr r s r rR zJSON.encode_date s8 ll&&cUl C 2;;s+U3r c | j j }| xs |dk( }|r|j dk( rd}nd}|j | }|r|j d s|j d r|d d dz }| j || y ) Nr r z%Y-%m-%dT%H:%M:%S%zz%Y-%m-%dT%H:%M:%S.%f%z-00:00+00:00Zr r microsecondr_ endswithr )r r` r r is_isorY s r rQ zJSON.encode_datetime s ll**(C5L ~~"+. KK ajj*ajj.B#2 A 1e$r c | j j }| xs |dk( }|r|j dk( rd}nd}|j | }|r|j d s|j d r|d d dz }| j || y ) Nr r z T%H:%M:%S%zzT%H:%M:%S.%f%zrb rc rd re rf )r r r r ri rY s r rS zJSON.encode_time s ll**(C5L }}!#&
JJsO ajj*ajj.B#2 A 1e$r c | j j }|r|dk( rt j | }n |dk( r t | }nt d|z | j
|| y )Nr hmszUnknown timedelta_format %r)r r r r rD r8 r )r r r r rY s r rT zJSON.encode_timedelta s[ ll++cUl,,R0A
E\BA :S @A A 1e$r c
|s| j | }|dk( r|j }d}|dk( r!|j dk( r|j }d}d}|dk( rd}n|dk( rd }n|dk( rd
}| j | rD | j || }||ur-|}|}| j | }||k7 r| j
|| y|dk( }d}|r't |d r t |j }n t | }|2 t | } | j j }
|
sM| j j! |j" } | j j! |j" d
z } d}
|r d}d}|
rd}nd}nd}d}|
s%| j j% t | }
|j' | |j' |
g }g } d } t) | }|d
z
}||u r t+ d| |r|| }| j d r | j d| }|}| j d r | j d| }|}t, j/ | sCt, j1 | r"| j j2 st+ d| t+ d| |j' ||d
z
f |j5 }| j
|| |rD|j' |j5 }| j
| |j7 | |j' | \| jS || y# t $ r Y w xY w# t $ r Y dw xY w# t $ r Y tw xY w# t $ r d } Y ww xY w# t $ r Y pw xY w# t $ r Y Zw xY w# t8 $ r Y nw xY w|r| j j: t< k( r#t> rtA |t> rtB ntD r tB t< fv rd nytG r|jI fd nX tD k( r|jI d n; tJ k( r|jI d n s tL k( r|jI d |D cg c]
}||d
nc c}w }}|
rd }n>t | | j jN k rd!}n|j' d" z d#| z }tQ | D ], \ } }| d kD r|j' | |j7 | . |
s?| | j jN kD r|j' d" z n|j' d$ |j' | y)%a Encodes just composite objects: dictionaries, lists, or sequences.
Basically handles any python type for which iter() can create
an iterator object.
This method is not intended to be called directly. Use the
encode() method instead.
r r. r7 r r} Nrb r0 rd re r1 r r
r r r r z : r r )r z%trying to encode an infinite sequencera rc zBobject properties (dictionary keys) must be strings in strict JSONzPobject properties (dictionary keys) can only be strings or numbers in ECMAScriptc $ | d | d fS r) r )r srts r r' z'JSON.encode_composite.. s 3qt9ad2C r )r c ( t | d | d fS r) )r r s r r' z'JSON.encode_composite.. s 3G!3MqQRt2T r c D t | d j | d fS r) )rD r rq s r r' z'JSON.encode_composite.. s 3qt9??3Dad2K r c t | d S r) )rD rq s r r' z'JSON.encode_composite.. s #ad) r r r r
z,
r )*r< r/ r r r{ r rH r r iterr2 rl rC r r r r r r
r nextr r r r is_allow_nonstring_keysr r
StopIterationr r r
r> r r r sort
SORT_ALPHA_CIr r r rO ) r r r rV r new_objrX r itnumitemsr indent0indentspaces_after_openerr
r dictcolonparts part_keyspart_idxobj2obj3newobjnewkeysubstate substate2pkseppnumro s @r rU zJSON.encode_composite s "!%!
s8
55I ,,< % 2 2 4HOOD(3 2$,$:$:$< i8 ..y9LL*e F
# #C /S
, "
d $0 % $ % $0 % $ %< !
ll,,-'#
3 (E ' (ci %? ? C c] NN(CNEJ& NN(TNVM) NN(KNMC: - NN(;N=?4= >bU2a5\ > >E >Ut|| > >> TF]+fn"+E"2
.h!8LL%##H-
.
dll = ==LL 0LL% LL s =M M 1 M$ M4 ;N& N N& 4N C+N& MM M! M!$ M10M14 NN NN& NN& N# N& "N##N& & N21N2 Rc t |d rHt t |d r3|j }||u r t d| | j || yy)aN This method is used to encode user-defined class objects.
The object being encoded should have a json_equivalent()
method defined which returns another equivalent object which
is easily JSON-encoded. If the object in question has no
json_equivalent() method available then None is returned
instead of a string so that the encoding will attempt the next
strategy.
If a caller wishes to disable the calling of json_equivalent()
methods, then subclass this class and override this method
to just return None.
rL z9object has a json_equivalent() method that returns itselfTF)r r rk rL r rH )r r r r s r rM zJSON.encode_equivalent sa 3) *x C* +0
&&(Ds{%OQT
OOD% (r c |}| j d r) | j d| }||ur| j || S t d| # t $ r Y w xY w)Nrf z0can not encode object into a JSON representation)r{ r rH r r )r r r rW s r rO zJSON.try_encode_default sj ==) *
7nn%5s; h& ??366 PRUVV
s A AAr )F)FF)NFF)4r r r r r r r rm r rF rj r r r rs ru rk r{ r r r r r r r r r r\ r r` r r r r ra r r r r r r r< r rH rP rR rQ rS rT rU rM rO r r r rU rU
s ( N
M
K"
L !%L V N &
P &&
S@j (T3(
" " $8JX
BHpd O&bSj,&\O,ob+Z:!x0dP25ncJ:.x04 % %%L0\:
Wr rU c @ t di |}|j | | }|S )a
Encodes a Python object into a JSON-encoded string.
* 'strict' (Boolean, default False)
If 'strict' is set to True, then only strictly-conforming JSON
output will be produced. Note that this means that some types
of values may not be convertable and will result in a
JSONEncodeError exception.
* 'compactly' (Boolean, default True)
If 'compactly' is set to True, then the resulting string will
have all extraneous white space removed; if False then the
string will be "pretty printed" with whitespace and
indentation added to make it more readable.
* 'encode_namedtuple_as_object' (Boolean or callable, default True)
If True, then objects of type namedtuple, or subclasses of
'tuple' that have an _asdict() method, will be encoded as an
object rather than an array.
If can also be a predicate function that takes a namedtuple
object as an argument and returns True or False.
* 'indent_amount' (Integer, default 2)
The number of spaces to output for each indentation level.
If 'compactly' is True then indentation is ignored.
* 'indent_limit' (Integer or None, default None)
If not None, then this is the maximum limit of indentation
levels, after which further indentation spaces are not
inserted. If None, then there is no limit.
CONCERNING CHARACTER ENCODING:
The 'encoding' argument should be one of:
* None - The return will be a Unicode string.
* encoding_name - A string which is the name of a known
encoding, such as 'UTF-8' or 'ascii'.
* codec - A CodecInfo object, such as as found by codecs.lookup().
This allows you to use a custom codec as well as those
built into Python.
If an encoding is given (either by name or by codec), then the
returned value will be a byte array (Python 3), or a 'str' string
(Python 2); which represents the raw set of bytes. Otherwise,
if encoding is None, then the returned value will be a Unicode
string.
The 'escape_unicode' argument is used to determine which characters
in string literals must be \u escaped. Should be one of:
* True -- All non-ASCII characters are always \u escaped.
* False -- Try to insert actual Unicode characters if possible.
* function -- A user-supplied function that accepts a single
unicode character and returns True or False; where True
means to \u escape that character.
Regardless of escape_unicode, certain characters will always be
\u escaped. Additionaly any characters not in the output encoding
repertoire for the encoding codec will be \u escaped as well.
r )rU r )r r r rK rI s r r r s% H
vA
XXc8
$F Mr c d}d}d}d}d}|j }g }t |j D ] \ } }
| dk( r t |
}|j | (| dk( r t |
}|j | J| dk( r|
}|j | c| dk( r|
}|j | || dk( s|
}|j | |D ] } || = t di |} | j
| ||xs ||xs | } |rId dl}
|d
u r |
j }| j D ]& }|j |j | d z ( |rsd dl}
|d
u r |
j }| j rS|j d
|z |j | j j d |j d|z | S )a Decodes a JSON-encoded string into a Python object.
== Optional arguments ==
* 'encoding' (string, default None)
This argument provides a hint regarding the character encoding
that the input text is assumed to be in (if it is not already a
unicode string type).
If set to None then autodetection of the encoding is attempted
(see discussion above). Otherwise this argument should be the
name of a registered codec (see the standard 'codecs' module).
* 'strict' (Boolean, default False)
If 'strict' is set to True, then those strings that are not
entirely strictly conforming to JSON will result in a
JSONDecodeError exception.
* 'return_errors' (Boolean, default False)
Controls the return value from this function. If False, then
only the Python equivalent object is returned on success, or
an error will be raised as an exception.
If True then a 2-tuple is returned: (object, error_list). The
error_list will be an empty list [] if the decoding was
successful, otherwise it will be a list of all the errors
encountered. Note that it is possible for an object to be
returned even if errors were encountered.
* 'return_stats' (Boolean, default False)
Controls whether statistics about the decoded JSON document
are returns (and instance of decode_statistics).
If True, then the stats object will be added to the end of the
tuple returned. If return_errors is also set then a 3-tuple
is returned, otherwise a 2-tuple is returned.
* 'write_errors' (Boolean OR File-like object, default False)
Controls what to do with errors.
- If False, then the first decoding error is raised as an exception.
- If True, then errors will be printed out to sys.stderr.
- If a File-like object, then errors will be printed to that file.
The write_errors and return_errors arguments can be set
independently.
* 'filename_for_errors' (string or None)
Provides a filename to be used when writting error messages.
* 'allow_xxx', 'warn_xxx', and 'forbid_xxx' (Booleans)
These arguments allow for fine-adjustments to be made to the
'strict' argument, by allowing or forbidding specific
syntaxes.
There are many of these arguments, named by replacing the
"xxx" with any number of possible behavior names (See the JSON
class for more details).
Each of these will allow (or forbid) the specific behavior,
after the evaluation of the 'strict' argument. For example,
if strict=True then by also passing 'allow_comments=True' then
comments will be allowed. If strict=False then
forbid_comments=True will allow everything except comments.
Unicode decoding:
-----------------
The input string can be either a python string or a python unicode
string (or a byte array in Python 3). If it is already a unicode
string, then it is assumed that no character set decoding is
required.
However, if you pass in a non-Unicode text string (a Python 2
'str' type or a Python 3 'bytes' or 'bytearray') then an attempt
will be made to auto-detect and decode the character encoding.
This will be successful if the input was encoded in any of UTF-8,
UTF-16 (BE or LE), or UTF-32 (BE or LE), and of course plain ASCII
works too.
Note though that if you know the character encoding, then you
should convert to a unicode string yourself, or pass it the name
of the 'encoding' to avoid the guessing made by the auto
detection, as with
python_object = demjson.decode( input_bytes, encoding='utf8' )
Callback hooks:
---------------
You may supply callback hooks by using the hook name as the
named argument, such as:
decode_float=decimal.Decimal
See the hooks documentation on the JSON.set_hook() method.
FNr! r" write_errorsfilename_for_errors write_stats)r r! r" r T)r r
z %s----- Begin JSON statistics
z | )r z %s----- End of JSON statistics
r )
r r r r r rU r r| stderrr r r r )ry r r r! r" r r r todelr r rK resultr| r( s r r r - s R MLL K
[[]F E ' C
IM LL
>
! 9L LL
>
! L LL
(
("% LL
=
K LL " 2J
vA XX $4 "1k F 4 ::L== C &&0C&DtK
$ **K << ?BU U V fll = =W = M N @CV V W Mr c ddl }ddl}|sd}t | t r| s t d |s4|j
j
| rt |j d| z t |fd|i|} t | d } |j | |j y# |j w xY w# t $ r w xY w)a Encodes a Python object into JSON and writes into the given file.
If no encoding is given, then UTF-8 will be used.
See the encode() function for a description of other possible options.
If the file already exists and the 'overwrite' option is not set
to True, then the existing file will not be overwritten. (Note,
there is a subtle race condition in the check so there are
possible conditions in which a file may be overwritten)
r Nr Expected a file namezFile exists: %rr wb)oserrnor> rD rC pathexistsIOErrorEEXISTr openr closer/ ) r r r overwriter r r jsondatafps r encode_to_filer s h $H.// 1ell$5$@AAc7H77H
(D
! HHX HHJBHHJ
s / B3 <B B03 B>c t | t r/ t | d } |j }|j n t
d t |fd|i|S # |j w xY w# t
$ r w xY w)zwDecodes JSON found in the given file.
See the decode() function for a description of other possible options.
rbr r )r> rD r readr r/ rC r )r r r r r s r decode_filer sy (C h%B
779
.// ( 8X 8 88
s A. A A+. A9c l e Zd ZdZdZdZdZdZd dZe d Z
d
d Z dd
Z d Z
y)jsonlinta This class contains most of the logic for the "jsonlint" command.
You generally create an instance of this class, to defined the
program's environment, and then call the main() method. A simple
wrapper to turn this into a script might be:
import sys, demjson
if __name__ == '__main__':
lint = demjson.jsonlint( sys.argv[0] )
return lint.main( sys.argv[1:] )
a Usage: %(program_name)s [ ...] [--] inputfile.json ...
With no input filename, or "-", it will read from standard input.
The return status will be 0 if the file is conforming JSON (per the
RFC 7159 specification), or non-zero otherwise.
GENERAL OPTIONS:
-v | --verbose Show details of lint checking
-q | --quiet Don't show any output (except for reformatting)
STRICTNESS OPTIONS (WARNINGS AND ERRORS):
-W | --tolerant Be tolerant, but warn about non-conformance (default)
-s | --strict Be strict in what is considered conforming JSON
-S | --nonstrict Be tolerant in what is considered conforming JSON
--allow=... -\
--warn=... |-- These options let you pick specific behaviors.
--forbid=... -/ Use --help-behaviors for more
STATISTICS OPTIONS:
--stats Show statistics about JSON document
REFORMATTING OPTIONS:
-f | --format Reformat the JSON text (if conforming) to stdout
-F | --format-compactly
Reformat the JSON simlar to -f, but do so compactly by
removing all unnecessary whitespace
-o filename | --output filename
The filename to which reformatted JSON is to be written.
Without this option the standard output is used.
--[no-]keep-format Try to preserve numeric radix, e.g., hex, octal, etc.
--html-safe Escape characters that are not safe to embed in HTML/XML.
--sort How to sort object/dictionary keys, is one of:
%(sort_options_help)s
--indent tabs | Number of spaces to use per indentation level,
or use tab characters if "tabs" given.
UNICODE OPTIONS:
-e codec | --encoding=codec Set both input and output encodings
--input-encoding=codec Set the input encoding
--output-encoding=codec Set the output encoding
These options set the character encoding codec (e.g., "ascii",
"utf-8", "utf-16"). The -e will set both the input and output
encodings to the same thing. The output encoding is used when
reformatting with the -f or -F options.
Unless set, the input encoding is guessed and the output
encoding will be "utf-8".
OTHER OPTIONS:
--recursion-limit=nnn Set the Python recursion limit to number
--leading-zero-radix=8|10 The radix to use for numbers with leading
zeros. 8=octal, 10=decimal.
REFORMATTING / PRETTY-PRINTING:
When reformatting JSON with -f or -F, output is only produced if
the input passed validation. By default the reformatted JSON will
be written to standard output, unless the -o option was given.
The default output codec is UTF-8, unless an encoding option is
provided. Any Unicode characters will be output as literal
characters if the encoding permits, otherwise they will be
\u-escaped. You can use "--output-encoding ascii" to force all
Unicode characters to be escaped.
MORE INFORMATION:
Use '%(program_name)s --version [-v]' to see versioning information.
Use '%(program_name)s --copyright' to see author and copyright details.
Use '%(program_name)s [-W|-s|-S] --help-behaviors' for help on specific checks.
%(program_name)s is distributed as part of the "demjson" Python module.
See %(homepage)s
EWOKNc ddl }ddl}|| _ |j j | | _ |r|| _ n|j | _ |r|| _ n|j | _ |r|| _ y|j | _ y)a Create an instance of a "jsonlint" program.
You can optionally pass options to define the program's environment:
* program_name - the name of the program, usually sys.argv[0]
* stdin - the file object to use for input, default sys.stdin
* stdout - the file object to use for outut, default sys.stdout
* stderr - the file object to use for error output, default sys.stderr
After creating an instance, you typically call the main() method.
r N) r r| program_pathr basename program_namestdinstdoutr )r r r r r r r| s r r zjsonlint.__init__y se ( GG , ,\ : DJ DJ DK **DK DK **DKr c
dj t t j D cg c] \ }}|t k7 r d|dd| c}} }| j
| j t |dz S c c}}w )z>A multi-line string containing the program usage instructions.r
z
z>12z - )r homepagesort_options_help)r sortedr r r _jsonlint_usager __homepage__)r smsdsorthelps r usagezjsonlint.usage sv 99 %_%:%:%< =
B? *,R0
## - -$!)'
s A1
c
| j }
d } |r|} nd } t ||dd|| || }
|
j D cg c] }|j dv s| }}|
j D cg c] }|j dv s| }}|r
| j }
n|r
| j }
n | j
}
|rG| j
}t |_ |dk( rd|_ nd|_ t |
j || } |
| fS c c}w c c}w # t $ r?}| j }
|r$|j ||j d Y d }~|
| fS d }~wt $ r:}| j }
|r |j |t! | d Y d }~|
| fS d }~ww xY w) NT)r r! r" r r r r r! )r r F)r r r
) SUCCESS_FAILr r r SUCCESS_WARNING
SUCCESS_OKr rM r r r r r. r r r/ rD )r r
verbose_fpreformat
show_statsinput_encodingoutput_encodingr rN jsonoptsrY reformattedstats_fpresultsr( r r encoptss r _lintcheck_datazjsonlint._lintcheck_data s ## !HH) ' " ! ' $$' % G( '~~ AS1SF (/~~V 9UVHV ++ .. //"--/%8"{*/3G,/4G, $NN_7 %%/ W M''G S#2H2H2J!KL: %%9 =''G S#c(!;<2 %%9 =s: C; C1 C1 C64C6; F2D>> F
-E??Fc
. dd l }
d } |r|dk( r+d} | j j }
|rM| j } n@d|z } t |d }|j }
|j |r | j } | j |
| ||||| | \ }}|| j k7 r~|r||r t |d }|j | |S t |
j d r'| j j j | |S | j j | |S || j k( r| r| j d | z |S || j k( r| r| j d
| z |S | r| j d| z |S # t $ r@}| j j | dt | d | j cY d }~S d }~ww xY w# t $ r7}| j j | dt | d d
}Y d }~|S d }~ww xY w)Nr r1 z : z%s: r r r
)r r r r r rN r r Fbufferz%sok
z%sok, with warnings
z
%shas errors
)r| r r r r r r r rD r r r r r r r )r r output_filenameverboser r r r r r r| r rN r r r( rY r s r
_lintcheckzjsonlint._lintcheck s
8s? Czz(H ![[
8#C
)(D) 779
![[
# 3 3 ! !) + 4
d'' 'H $ ot4BHH[)$ JJ KK&&,,[9 KK%%k2
'J X^ , ,,
, 4s : ; - 3 4O
) !!SX">?(((
), $KK%%CS&BC #G #$s5 ,F ) G G5G G G H ,HHc ddl }ddl}ddl}d}d}d}d}d} d}
d} d} t t ddd}
|j |d g d
\ }}|D ] \ }}|dv s d} |D ] \ }}|dv r'| j j | j y|dk( r| j j dd| j iz | j j d|
d z | j j ddz | j j d t dci |
}t |j D ]h }|j | }|j! | }| j j |j# dd|j% dd d d|d j y|d k( r| j j | j d t& d!t( d t* d" |dk( r#| j j d#t, d |dk( rQ| j j d$|j. j% d d d | j j d% | j j d&|j0 fz | j j d'|j2 d | j j d(t4 fz | j j d)t6 fz t9 d* t9 d+ k( rd,}nd-}| j j d.|d t: rd-}nd,}| j j d/|d y|d0k( rl| j j | j d1 | j j d2t< d3 | j j t> y|dv rd}|d4v rd}|d5v rt@ |
d< d|
d6< |d7v r tB |
d< |d8v r t |
d< |d9v r d}d|
d:< |d;v r d|
d:< d<}|d=v rd} |d>v r|}
|d?v r|} |} d}|d@v r|} d} |dAv r|} |dBv rd|
dC< |dDv r"|dEd }||
v r|
|xx dF|z z
cc< 2||
|< 9|dGv rd|
d6< D|dHv rd|
d6< O|dIk( r||
dJ< [|dKv r!|dLv r dM|
dN< dM|
dO< o tE | |
dN< |dQk( r tE | |
dO< |dSk( r tE | |
dT< |dVk( rK|j# }|dWk( r tH |
dX< |dYk( r tJ |
dX< |dZk( r tL |
dX< t |
dX< |d[k( ra tE | }d\} |jN } ||kD r"| j j d]| |fz y|| kD sN |jP | b| j j d_|z y d|
d`< t dci |
} |sdg}|D ]- } | jS | |
||| | | | a } | | jT k7 rd}/ |syy# |j
$ r@}| j j d |j d | j d
Y d}~yd}~ww xY w# tF $ r | j j dP Y yw xY w# tF $ r | j j dR Y yw xY w# tF $ r | j j dU Y yw xY w# tF $ r" | j j d^|z Y yw xY w# tV $ r1 |j j db |jX d Y nw xY w)dai The main routine for program "jsonlint".
Should be called with sys.argv[1:] as its sole argument.
Note sys.argv[0] which normally contains the program name
should not be passed to main(); instead this class itself
is initialized with sys.argv[0].
Use "--help" for usage syntax, or consult the 'usage' member.
r NTr Fr d )r r r r z vqfFe:o:sSW) r quietr zformat-compactlyr rI r nonstrictrY z html-safezxml-safez encoding=zinput-encoding=zoutput-encoding=zsort=zrecursion-limit=zleading-zero-radix=z keep-formatzno-keep-formatzindent=zindent-amount=z
indent-limit=zindent-tab-width=zmax-items-per-line=zallow=zwarn=zforbid=zdeny=helpzhelp-behaviorsversion copyrightzError: z. Use "z --help" for usage information.
r
)z-vz --verbose)z-hz--helpz--help-behaviorsa#
BEHAVIOR OPTIONS:
These set of options let you control which checks are to be performed.
They may be turned on or off by listing them as arguments to one of
the options --allow, --warn, or --forbid ; for example:
%(program_name)s --allow comments,hex-numbers --forbid duplicate-keys
r z"The default shown is for %s mode
r z%-7s %-25s %s
)Default
Behavior_name DescriptionzU------- ------------------------- --------------------------------------------------
r r ru r1 25r
z --versionz (z
) version z)
z
demjson from zPython version: z%This python implementation supports:
z * Max unicode: U+%X
z * Unicode version: z* * Floating-point significant digits: %d
z' * Floating-point max 10^exponent: %d
r r# NoYesz% * Floating-point has signed-zeros: z * Decimal (bigfloat) support: z --copyrightz9 is distributed as part of the "demjson" python package.
zSee z
)z-qz--quiet)z-sz--strictr )z-Sz --nonstrict)z-Wz
--tolerant)z-fz--formatr )z-Fz--format-compactlyr )z--stats)z-oz--output)z-ez
--encodingz--output-encodingz--input-encoding)z --html-safez
--xml-safer )z--allowz--warnz--forbidr. r )z
--keep-format)z--no-keep-formatz--leading-zero-radixr )z--indentz--indent-amount)tabtabsr r r z$Indentation amount must be a number
zindent-tab-widthz'Indentation tab width must be a number
z--max-items-per-liner z$Max items per line must be a number
z--sortr r r r z--recursion-limiti z3Recursion limit must be a number between %d and %d
z%Recursion limit must be a number: %r
zUnknown option %r
r )r r r r r r r z
jsonlint interrupted!
r )-r| getoptr! r r GetoptErrorr r r r r r r r r rn rt r} r r __version____date____file__r r unidata_versionr r rD r9 r __credits__rG rM r r8 r ry r getrecursionlimitsetrecursionlimitr r KeyboardInterruptexit) r argvr| r r! recursion_limitrY r r r r r r kwoptionsoptsr r( optr rK r r` descszerohas_decr r max_limit old_limitr fnrcs r mainz
jsonlint.main- s ('
! $% "
, !%JD$\ HC))
o HC&& !!$**-** !! &t'8'89
: !!:Yx=PP !!%(SS !!"RS -9- &q 7 Hx0A ..x8DKK%% 779h&6&6sC&@$H # !!(((KK d?KK%%X&GHd?KK%%25++2E2EdC2PR KK%%&NOKK%%&?3>>BS&STKK%%7B7R7RT KK%%E*,- KK%%Bl_T 3x3t9, $ %KK%%GLN "'"&KK%%BIK
% !!((+ !!L"BC !!+.++ )) **&7 (#+0 -(--&9 (#,,&5 (#** 05 ,-4404 ,-& $ !
**"%,,!$"%!&,-"%!&+,!$55)- +&99 QRY& f%s2%(+If%**+/ -(--+0 -(..25 ./77/)12Io.45I 01!58X /2 ** 47HI 01 .. 69#hI 23 iik'>-7Ik*J&-:Ik*J&-:Ik*-7Ik*++?&)#hO
!'I 5 5 5 7I&2 )) R () 4 5 !(94---o> !!"7#"=>_o d (+ #$ ,), 6D B
__$3 # % )#1$3 % % ( $G! * { !! KK 77D - -/
` & ! ))*QR ! " KK%%&PQ " KK%%&MN " KK%%&NQT&TU V %
!<=
sq X& Y8 Z#4[ [96*\'&Y556Y00Y58$Z Z #$[
[ $[65[69'\$#\$'6]! ]!)r NNN)NFFNNTr N)FFFNNTN)r r r r r r r r r r r r r r r r r r r s VOn LOJ %@
$ >&H BHbr r rR r r )r F)dr
__author__r r r __version_info__r r r rF r r r| vir r r9 _py_minorrl content_typefile_extr r
r9 rB r^ r r r ra rc rg r r rm rn r r r r r r r r r r r r# r r r r/ r r r r r. r r r r r r r rG r rM r= r> r r r r r r r r r r ra r r r ry r r r r rH r r: r r
r rU r r r r r r r r r sS rh H
5 . 2K;~/JK $%5 ( 88RXXIy " V 01 (- N"b /EU.K + |2 v
! ; | ./ S& 2 s 2 r
f@F f@\Rf Rt[+f [+F`$f `$P
I =
z
zz i H/ H2 i H/ H<.06 .0lN+ N+lD6 DV
" ) [T4 [T|
;>.9?
. < 4O '6%9 O 'nM%W6 M%WfJFRcL"J90v W{ ( a5"Q%Iy(s H H H