ó
þEYc@sŸdZd
dl
mZ
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	yd
dl
mZmZ
Wn'e
k
r­


d
dlmZmZ
n
Xd
dlmZmZ
dZdZdZd	Ze	jd2krúeefZndef
d
„ƒYZdef
d„ƒYZdef
d„ƒYZdeefd„ƒYZd„Zd„Z e ƒe_!e"d„
Z#d„Z$de%f
d„ƒYZ&de%f
d„ƒYZ'de'f
d„ƒYZ(de'f
d„ƒYZ)d e'f
d!„ƒYZ*d"e'f
d#„ƒYZ+d$e'f
d%„ƒYZ,d&e'f
d'„ƒYZ-e.d(„
Z/d)„Z0d3d4d*„Z1d+„Z2d,„Z3d-„Z4d.„Z5d/„Z6d0„Z7d1„Z8dS(5u Apply JSON-Patches (RFC 6902) iÿÿÿÿ(
tunicode_literalsN(tMutableMappingtMutableSequence(tJsonPointertJsonPointerExceptionu Stefan Kögl <stefan@skoegl.net>u1.16u0https://github.com/stefankoegl/python-json-patchuModified BSD LicenseiitJsonPatchExceptionc
BseZ
dZRS(
uBase Json Patch exception(t__name__t
__module__t__doc__(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR@s
tInvalidJsonPatchc
BseZ
dZRS(
u, Raised if an invalid JSON Patch is created (RRR(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR	Ds
tJsonPatchConflictc
BseZ
dZRS(
u
Raised if patch could not be applied due to conflict situation such as:
    - attempt to add object key then it already exists;
    - attempt to operate with nonexistence object key;
    - attempt to insert value to array at position beyond of it size;
    - etc.
    (RRR(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR
HstJsonPatchTestFailedc
BseZ
dZRS(
u A Test operation failed (RRR(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRQs
c
CsQtj
tƒ
}
x%|D]\}}|
|j|ƒ

qWtd
„|
jƒDƒ
ƒ
S(u'Convert duplicate keys values to lists.c
ss=|]3\}
}|
t|ƒ
dkr.|d
n|fV
qdS(i
iN(
tlen(t.0tkeytvalues((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pys	<genexpr>^s
(tcollectionstdefaultdicttlisttappendtdicttitems(t
ordered_pairstmdictRtvalue((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt	multidictUs


c
Csetj
dkr'tjtjƒ
j}ntjtjƒ
j}d|krOtjSt	j
tjdtƒ

S(u
 adds the object_pairs_hook parameter to json.load when possible

    The "object_pairs_hook" parameter is used to handle duplicate keys when
    loading a JSON object. This parameter does not exist in Python 2.6. This
    methods returns an unmodified json.load for Python 2.6 and a partial
    function with object_pairs_hook set to multidict for Python versions that
    support the parameter. iuobject_pairs_hooktobject_pairs_hook(ii(tsystversion_infotinspectt	signaturetjsontloadt
parameterst
getargspectargst	functoolstpartialR(
R#((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pytget_loadjsoncs	


cCs=t|
t
ƒr!tj|
ƒ
}
nt|
ƒ
}
|
j||ƒS(
uOApply list of patches to specified json document.

    :param doc: Document object.
    :type doc: dict

    :param patch: JSON patch as list of dicts or raw JSON-encoded string.
    :type patch: list or str

    :param in_place: While :const:`True` patch will modify target document.
                     By default patch will be applied to document copy.
    :type in_place: bool

    :return: Patched document object.
    :rtype: dict

    >>> doc = {'foo': 'bar'}
    >>> patch = [{'op': 'add', 'path': '/baz', 'value': 'qux'}]
    >>> other = apply_patch(doc, patch)
    >>> doc is not other
    True
    >>> other == {'foo': 'bar', 'baz': 'qux'}
    True
    >>> patch = [{'op': 'add', 'path': '/baz', 'value': 'qux'}]
    >>> apply_patch(doc, patch, in_place=True) == {'foo': 'bar', 'baz': 'qux'}
    True
    >>> doc == other
    True
    (t
isinstancet
basestringt	JsonPatchtfrom_stringtapply(tdoctpatchtin_place((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pytapply_patchxs

cCsPtj
||
ƒ}|j|ƒ
}||
kr@tj
||
tƒStj
||
ƒS(
uÇ
Generates patch by comparing of two document objects. Actually is
    a proxy to :meth:`JsonPatch.from_diff` method.

    :param src: Data source document object.
    :type src: dict

    :param dst: Data source document object.
    :type dst: dict

    >>> src = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
    >>> dst = {'baz': 'qux', 'numbers': [1, 4, 7]}
    >>> patch = make_patch(src, dst)
    >>> new = patch.apply(src)
    >>> new == dst
    True
    (R)t	from_diffR+tFalse(tsrctdstR-tnew((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt
make_patchs



R)cBs¡eZ
dZd
„Zd„Zd„ZeZd„Zd„Zd„Z	d„Z
ed„ƒ
Zee
d	„
ƒ
Zd
„Zed„ƒ
Zed„
Zd
„ZRS(ugA JSON Patch is a list of Patch Operations.

    >>> patch = JsonPatch([
    ...     {'op': 'add', 'path': '/foo', 'value': 'bar'},
    ...     {'op': 'add', 'path': '/baz', 'value': [1, 2, 3]},
    ...     {'op': 'remove', 'path': '/baz/1'},
    ...     {'op': 'test', 'path': '/baz', 'value': [1, 3]},
    ...     {'op': 'replace', 'path': '/baz/0', 'value': 42},
    ...     {'op': 'remove', 'path': '/baz/1'},
    ... ])
    >>> doc = {}
    >>> result = patch.apply(doc)
    >>> expected = {'foo': 'bar', 'baz': [42]}
    >>> result == expected
    True

    JsonPatch object is iterable, so you could easily access to each patch
    statement in loop:

    >>> lpatch = list(patch)
    >>> expected = {'op': 'add', 'path': '/foo', 'value': 'bar'}
    >>> lpatch[0] == expected
    True
    >>> lpatch == patch.patch
    True

    Also JsonPatch could be converted directly to :class:`bool` if it contains
    any operation statements:

    >>> bool(patch)
    True
    >>> bool(JsonPatch([]))
    False

    This behavior is very handy with :func:`make_patch` to write more readable
    code:

    >>> old = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
    >>> new = {'baz': 'qux', 'numbers': [1, 4, 7]}
    >>> patch = make_patch(old, new)
    >>> if patch:
    ...     # document have changed, do something useful
    ...     patch.apply(old)    #doctest: +ELLIPSIS
    {...}
    cCs@|
|_it
d
6td6td6td6td6td6|_dS(Nuremoveuaddureplaceumoveutestucopy(R-tRemoveOperationtAddOperationtReplaceOperationt
MoveOperationt
TestOperationt
CopyOperationt
operations(tselfR-((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt__init__çs
	





c


Cs
|jƒS(
ustr(self) -> self.to_string()(
t	to_string(
R=((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt__str__ósc

Cs
t|j
ƒ
S(
N(tboolR-(
R=((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt__bool__÷s
c

Cs
t|j
ƒ
S(
N(titerR-(
R=((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt__iter__üs
c

Cstt
|jƒ
ƒ
S(
N(thashttuplet_ops(
R=((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt__hash__ÿs
cCs#t|
t
ƒstS|j|
jkS(
N(R'R)R1RG(R=tother((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt__eq__
s


cCs||
kS(
N((R=RI((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt__ne__
s
cCstj
|
ƒ
}||ƒ
S(
u¸Creates JsonPatch instance from string source.

        :param patch_str: JSON patch as raw string.
        :type patch_str: str

        :return: :class:`JsonPatch` instance.
        (Rtloads(tclst	patch_strR-((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR*

s	
csL‡‡
fd
†‰‡f
d†‰‡f
d†‰
|tˆg|
|ƒƒ
ƒ
S(uOCreates JsonPatch instance based on comparing of two document
        objects. Json patch would be created for `src` argument against `dst`
        one.

        :param src: Data source document object.
        :type src: dict

        :param dst: Data source document object.
        :type dst: dict

        :return: :class:`JsonPatch` instance.

        >>> src = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
        >>> dst = {'baz': 'qux', 'numbers': [1, 4, 7]}
        >>> patch = JsonPatch.from_diff(src, dst)
        >>> new = patch.apply(src)
        >>> new == dst
        True
        c3sÆ|
|krdSt|
t
ƒrSt|t
ƒrSx‘ˆ||
|ƒD]}|V
qAWnot|
tƒr–t|tƒr–xNˆ
||
|ƒD]}|V
q„Wn,tj|ƒ
}id
d6|jd6|d6V
dS(Nureplaceuopupathuvalue(R'R
RRt
from_partstpath(RPRRIt	operationtptr(t
compare_dictst
compare_lists(s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pytcompare_values+
s










c3sáxƒ|
D]{}||krKtj
||g
ƒ
}id
d6|jd6V
qn||g
}x'ˆ||
|||ƒD]}|V
qsWqWxT|D]L}||
krtj
||g
ƒ
}idd6|jd6||d6V
qqWdS(Nuremoveuopupathuadduvalue(RRORP(RPR2R3RRRtcurrentRQ(
RU(s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRS:
s








!










cst||
|d
ˆƒ
S(Ntoptimization(
t_compare_lists(RPR2R3(
RW(s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRTJ
s
(
R(RMR2R3RW((RSRTRURWs>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR0
sc

Cstj
|jƒ
S(
u!Returns patch set as JSON string.(RtdumpsR-(
R=((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR?O
sc

Cstt
|j|jƒƒ
S(
N(RFtmapt_get_operationR-(
R=((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRGS
scCs?|stj
|
ƒ
}
nx |jD]}|j|
ƒ
}
q"W|
S(
u/
Applies the patch to given object.

        :param obj: Document object.
        :type obj: dict

        :param in_place: Tweaks way how patch would be applied - directly to
                         specified `obj` or to his copy.
        :type in_place: bool

        :return: Modified `obj`.
        (tcopytdeepcopyRGR+(R=tobjR.RQ((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+W
s



cCsd
|
krtdƒ
‚
n|
d
}t
|tƒsCtdƒ
‚
n||jkrjtdj|ƒ
ƒ
‚
n|j|}||
ƒ
S(Nuopu&Operation does not contain 'op' memberuOperation must be a stringuUnknown operation {0!r}(R	R'R(R<tformat(R=RQtopRM((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR[l
s






(RRRR>R@RBt__nonzero__RDRHRJRKtclassmethodR*tTrueR0R?tpropertyRGR1R+R[(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR)¹s -
							
8	tPatchOperationc
Bs;eZ
dZd
„Zd„Zd„Zd„Zd„ZRS(u'A single operation inside a JSON Patch.cCs,|
d
|_t
|jƒ
|_|
|_dS(Nupath(tlocationRtpointerRQ(R=RQ((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR>
s



cCstd
ƒ
‚
dS(uAAbstract method that applies patch operation to specified object.u!should implement patch operation.N(
tNotImplementedError(R=R^((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+„
sc

Cstt
|jjƒƒ
ƒ
S(
N(REt	frozensetRQR(
R=((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRHˆ
s
cCs#t|
t
ƒstS|j|
jkS(
N(R'ReR1RQ(R=RI((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRJ‹
s


cCs||
kS(
N((R=RI((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRK
s
(RRRR>R+RHRJRK(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRe|
s
				R6c
BseZ
dZd
„ZRS(u/Removes an object property or an array element.cCs^|jj
|
ƒ
\}}y||=Wn4ttfk
rY
}
d
j|ƒ
}t|ƒ
‚
n
X|
S(Nu&can't remove non-existent object '{0}'(Rgtto_lasttKeyErrort
IndexErrorR_R
(R=R^tsubobjtparttextmsg((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+—
s





(RRRR+(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR6”
s
R7c
BseZ
dZd
„ZRS(u,Adds an object property or an array element.cCs
y|jd
}Wnt
k
r2
}
tdƒ
‚
n
X|jj|
ƒ
\}}t|tƒr¶|dkrv|j|ƒ

q
|t|ƒ
ks”|dkr£t	dƒ
‚
q
|j
||ƒ
nLt|tƒrç|dkrÚ|}
q
|||<nt
djt|ƒ
ƒ
ƒ
‚
|
S(Nuvalueu/The operation does not contain a 'value' memberu
-iucan't insert outside of listuinvalid document type {0}(RQRkR	RgRjR'RRRR
tinsertR
tNonet	TypeErrorR_ttype(R=R^RRoRmRn((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+¥
s$










	
(RRRR+(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR7¢
s
R8c
BseZ
dZd
„ZRS(u=Replaces an object property or an array element by new value.cCsÿy|jd
}Wnt
k
r2
}
tdƒ
‚
n
X|jj|
ƒ
\}}|dkr[|St|tƒrš|t|ƒ
ksˆ|dkrñt	dƒ
‚
qñnWt|t
ƒrÖ||krñdj|ƒ
}t	|ƒ
‚
qñntdjt
|ƒ
ƒ
ƒ
‚
|||<|
S(Nuvalueu/The operation does not contain a 'value' memberiucan't replace outside of listu'can't replace non-existent object '{0}'uinvalid document type {0}(RQRkR	RgRjRrR'RRR
R
R_RsRt(R=R^RRoRmRnRp((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+Ç
s$













(RRRR+(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR8Ä
s
R9c
BseZ
dZd
„ZRS(u=Moves an object property or an array element to new location.cCs(
yt|j
d
ƒ
}Wntk
r8
}
tdƒ
‚
n
X|j|
ƒ
\}}y||}Wn+ttfk
r‰
}
tt|ƒ
ƒ
‚
n
X|j|kr|
St	|t
ƒrÍ|jj|ƒ
rÍtdƒ
‚
ntidd6|j
d
d6ƒ
j
|
ƒ
}
tidd6|jd6|d6ƒ
j
|
ƒ
}
|
S(	Nufromu.The operation does not contain a 'from' memberu(Cannot move values into its own childrenuremoveuopupathuadduvalue(RRQRkR	RjRlR
tstrRgR'R
tcontainsR6R+R7Rf(R=R^tfrom_ptrRoRmRnR((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+å
s2















	





	(RRRR+(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR9â
s
R:c
BseZ
dZd
„ZRS(u!Test value by specified location.cCsäyF|jj
|
ƒ
\}}|dkr0|}n|jj||ƒ}Wn%tk
rm
}
tt|ƒ
ƒ
‚
n
Xy|jd
}Wntk
r 
}
t	dƒ
‚
n
X||kràd}t|j
|t|ƒ
|t|ƒ
ƒƒ
‚
n|
S(Nuvalueu/The operation does not contain a 'value' memberu0{0} ({1}) is not equal to tested value {2} ({3})(RgRjRrtwalkRRRuRQRkR	R_Rt(R=R^RmRntvalRoRRp((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+s"



	









(RRRR+(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR:s
R;c
BseZ
dZd
„ZRS(uA Copies an object property or an array element to a new location cCsÄyt|j
d
ƒ
}Wntk
r8
}
tdƒ
‚
n
X|j|
ƒ
\}}ytj||ƒ
}Wn+ttfk
r’
}
tt	|ƒ
ƒ
‚
n
Xt
idd6|jd6|d6ƒ
j|
ƒ
}
|
S(Nufromu.The operation does not contain a 'from' memberuadduopupathuvalue(
RRQRkR	RjR\R]RlR
RuR7RfR+(R=R^RwRoRmRnR((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR+&s 















	(RRRR+(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR;#s
cCs>tt
||
|t|
|ƒŒƒ
}|r:tt|ƒ
ƒ
S|S(
u7Compares two lists objects and return JSON patch about.(Rt_comparet_split_by_common_seqt	_optimize(RPR2R3RWR-((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRX<s$


cCsr
t|ƒ
t|
ƒ
}}t
t|ƒ
ƒ
}gt|ƒ
D]}d
g
|^q8}d
}d\}}	x
tjt|ƒ
|ƒD]è\}
}||
|
|krV
|
d
ks´|d
krÅd||
|<n"||
d|dd||
|<||
||kr
||
|}n||
||krd
|
|d|
df}||d|df}	qd
q|d
||
|<q|W||	fS(uª
Returns pair of ranges of longest common subsequence for the `src`
    and `dst` lists.

    >>> src = [1, 2, 3, 4]
    >>> dst = [0, 1, 2, 3, 5]
    >>> # The longest common subsequence for these lists is [1, 2, 3]
    ... # which is located at (0, 3) index range for src list and (1, 4) for
    ... # dst one. Tuple of these ranges we should get back.
    ... assert ((0, 3), (1, 4)) == _longest_common_subseq(src, dst)
    ii
N(NN(RRtrangeRrt	itertoolstproduct(R2R3tlsrctldsttdranget
_tmatrixt
zt	range_srct	range_dstt
it
j((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt_longest_common_subseqDs"

&


%


"





c
CsK
|d
|dkr|nd}|d
|dkr:|nd}|sPd|gS|
s`|dgSt
||
ƒ\}}|dks|dkr—||gSt||d
 |
|d
 |d
|d
|d
f|d
|d
|d
fƒt||d|
|d|d
|d|d
t|ƒ
f|d
|d|d
t|
ƒ
fƒgS(uåRecursively splits the `dst` list onto two parts: left and right.
    The left part contains differences on left from common subsequence,
    same as the right part by for other side.

    To easily understand the process let's take two lists: [0, 1, 2, 3] as
    `src` and [1, 2, 4, 5] for `dst`. If we've tried to generate the binary tree
    where nodes are common subsequence for both lists, leaves on the left
    side are subsequence for `src` list and leaves on the right one for `dst`,
    our tree would looks like::

        [1, 2]
       /         [0]       []
             /            [3]   [4, 5]

    This function generate the similar structure as flat tree, but without
    nodes with common subsequences - since we're don't need them - only with
    left and right leaves::

        []
       /     [0]  []
        /      [3]  [4, 5]

    The `bx` is the absolute range for currently processed subsequence of
    `src` list.  The `by` means the same, but for the `dst` list.
    ii
N(RrRŠR{R(R2R3tbxtbyt
xt
y((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR{ds 
 










#
ccs5x.t||
|||d
ƒD]\}}|V
qWdS(uESame as :func:`_compare_with_shift` but strips emitted `shift` value.iN(
t_compare_with_shift(RPR2R3tlefttrightR`Rƒ((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRz™s(
ccs
t|t
ƒrIxwt||
|d
||Œ
D]\}}||fV
q+Wn@|dk	r‰x1t||
||ƒD]\}}||fV
qkWnt|t
ƒrÒxwt||
|d
||Œ
D]\}}||fV
q´Wn@|dk	r
x1t||||ƒD]\}}||fV
qôWndS(u
Recursively compares differences from `left` and `right` sides
    from common subsequences.

    The `shift` parameter is used to store index shift which caused
    by ``add`` and ``remove`` operations.

    Yields JSON patch operations and list index shift.
    tshiftN(R'RRRrt
_compare_leftt_compare_right(RPR2R3RR‘R’titem((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRŸs	




"





"
ccs¨|\}}|d
kr't|
ƒ
}nxzt
t||||ƒƒ
D][}tj|t|ƒ
g
ƒ
}idd6|
||d6|jd6|dfV
|d8}qEWdS(u`Yields JSON patch ``remove`` operations for elements that are only
    exists in the `src` list.iÿÿÿÿuremoveuopuvalueupathi
N(RtreversedR}RRORuRP(RPR2RR’tstarttendtidxRR((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR“¹s

$



ccs–|\}}|d
kr't|
ƒ
}nxht
||ƒD]W}tj|t|ƒ
g
ƒ
}idd6|jd6|
|d6|dfV
|d7}q7WdS(u\Yields JSON patch ``add`` operations for elements that are only
    exists in the `dst` listiÿÿÿÿuadduopupathuvaluei
N(RR}RRORuRP(RPR3R‘R’R—R˜R™RR((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR”Ïs




c
cse
g}
i}i}td
dgƒ
}xð|D]è}t
|dttfƒ}|d|krvt||d|ƒ
q+n|rá|d|krá||d}t|d|dgƒ
|krát||ƒ
|j|dƒ

q+qán|
j|ƒ

|||d<|r+|||d<q+q+W|jƒ
|jƒ
x3|
D]+}|ddkrX
|jdƒ

n|V
q2
WdS(ur
Optimizes operations which was produced by lists comparison.

    Actually it does two kinds of optimizations:

    1. Seeks pair of ``remove`` and ``add`` operations against the same path
       and replaces them with ``replace`` operation.
    2. Seeks pair of ``remove`` and ``add`` operations for the same value
       and replaces them with ``move`` operation.
    uadduremoveuvalueupathuopN(	tsetR'R
Rt_optimize_using_replacet_optimize_using_movetpopRtclear(R<tresulttops_by_pathtops_by_valuet
add_removeR•thashable_valuet	prev_item((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR|Þs4












 



	












cCs{
d
|d<|
ddkrw
t|d|
dƒ}t
|dtƒrÌt
|
dtƒrÌt|djƒƒ
dkrÌt|djƒƒ
}t|
djƒƒ
}||@|krÌt|
d|dƒ}qÌnt|jƒ
dkrf
|jdddkrf
|jddrf
|jddjd	ƒ
d|dkrf
|d|jdd|d<|jdd|d<qw
|
d|d<nd
S(u‰Optimises by replacing ``add``/``remove`` with ``replace`` on same path

    For nested strucures, tries to recurse replacement, see #36 ureplaceuopuadduvaluei
iuremoveupathu
/N(R5R'RRtkeysRšR-tsplit(tprevtcurR-tprev_settcur_set((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyR›s

B





9

cCsµd
|d<|
d|df|d|
dfg|
ddk\}}|
ddkrm||d<||d<nD|jddƒ\}}t
|ƒ
d}|d||d<||d<d	S(
u‰Optimises JSON patch by using ``move`` operation instead of
    ``remove` and ``add`` against the different paths but for the same value.umoveuopupathuaddufromu
/i
u/%dN(trsplittint(R¤R•t	move_fromtmove_tothead((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyRœ s









(ii(iiÿÿÿÿ(iiÿÿÿÿ(9Rt
__future__RRR\R$RR~RRtcollections.abcR
RtImportErrortjsonpointerRRt
__author__t__version__t__website__t__license__RtbytesRuR(t	ExceptionRR	R
tAssertionErrorRRR&R R1R/R5tobjectR)ReR6R7R8R9R:R;RcRXRŠR{RzRR“R”R|R›Rœ(((s>/home/tvault/.virtenv/lib/python2.7/site-packages/jsonpatch.pyt<module>!s\













			%	Ã"&	 5					*