o

�]Lb��@sH
dZd
dl
mZ
d
dlZd
dlZddlmZ
ddlmZ
ddl	m
Z

dd	lmZm
Z
mZmZmZ
dd
lmZ
ddlmZmZmZ
ddlmZ
dZGd
d�de�Zd1dd�
Zd1dd�
Zd2dd�
Zd1dd�
Zdd�Zdd�Z ej!ddd�Gdd�de��
Z"d d!�Z#d"d#�Z$d$Z%d%d&�Z&d'd(�Z'd)d*�Z(d1d+d,�
Z)Gd-d.�d.e�Z*d/d0�Z+dS)3z4Helper class to compute deltas stored inside revlogs�)
�absolute_importN��
�nullrev)
�
_)
�getattr�
)�COMP_MODE_DEFAULT�COMP_MODE_INLINE�COMP_MODE_PLAIN�REVIDX_ISCENSORED�REVIDX_RAWTEXT_CHANGING_FLAGS)
�attr)�error�mdiff�util)
�flagutilc@sBeZ
dZd
Zddd�
Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	dS)�_testrevlogz)minimalist fake revlog to use in doctests��?r
�cCs&|
|_||_
||_t|�
|_d
|_d
S)z.data is an list of revision payload boundariesN)�_data�_srdensitythreshold�
_srmingapsize�set�	_snapshot�index)�self�data�density�mingap�snapshotrr�>/usr/lib/python3/dist-packages/mercurial/revlogutils/deltas.py�__init__-s






z_testrevlog.__init__cCs&|
tkrd
S|
d
krd
S|j
|
dS�Nr
r�rr�r�revrrr!�start5s





z_testrevlog.startcCs|
tkrd
S|j
|
S�Nr
r$r%rrr!�end<�



z_testrevlog.endcCs|�|
�
|�
|
�
S�
N�r)r'r%rrr!�lengthAs
z_testrevlog.lengthc

Cs
t|j
�
Sr+)�lenr)
rrrr!�__len__D�

z_testrevlog.__len__cCs|
tkrd
S|
|j
vS)NT)rrr%rrr!�
issnapshotGr*z_testrevlog.issnapshotN)rr
r)
�__name__�
__module__�__qualname__�__doc__r"r'r)r-r/r1rrrr!r*s

rc#sj�|d
u
rt|�j
�}t�jdd
�}|d
ur�f
dd�}||
�j�j
�D]}t�||�D]}|V
q,q$d
S)a�slice revs to reduce the amount of unrelated data to be read from disk.

    ``revs`` is sliced into groups that should be read in one time.
    Assume that revs are sorted.

    The initial chunk is sliced until the overall density (payload/chunks-span
    ratio) is above `revlog._srdensitythreshold`. No gap smaller than
    `revlog._srmingapsize` is skipped.

    If `targetsize` is set, no chunk larger than `targetsize` will be yield.
    For consistency with other slicing choice, this limit won't go lower than
    `revlog._srmingapsize`.

    If individual revisions chunk are larger than this limit, they will still
    be raised individually.

    >>> data = [
    ...  5,  #00 (5)
    ...  10, #01 (5)
    ...  12, #02 (2)
    ...  12, #03 (empty)
    ...  27, #04 (15)
    ...  31, #05 (4)
    ...  31, #06 (empty)
    ...  42, #07 (11)
    ...  47, #08 (5)
    ...  47, #09 (empty)
    ...  48, #10 (1)
    ...  51, #11 (3)
    ...  74, #12 (23)
    ...  85, #13 (11)
    ...  86, #14 (1)
    ...  91, #15 (5)
    ... ]
    >>> revlog = _testrevlog(data, snapshot=range(16))

    >>> list(slicechunk(revlog, list(range(16))))
    [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
    >>> list(slicechunk(revlog, [0, 15]))
    [[0], [15]]
    >>> list(slicechunk(revlog, [0, 11, 15]))
    [[0], [11], [15]]
    >>> list(slicechunk(revlog, [0, 11, 13, 15]))
    [[0], [11, 13, 15]]
    >>> list(slicechunk(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
    [[1, 2], [5, 8, 10, 11], [14]]

    Slicing with a maximum chunk size
    >>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=15))
    [[0], [11], [13], [15]]
    >>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=20))
    [[0], [11], [13, 15]]

    Slicing involving nullrev
    >>> list(slicechunk(revlog, [-1, 0, 11, 13, 15], targetsize=20))
    [[-1, 0], [11], [13, 15]]
    >>> list(slicechunk(revlog, [-1, 13, 15], targetsize=5))
    [[-1], [13], [15]]
    N�slicechunktodensitycst�||
|�Sr+)
�_slicechunktodensity)�
x�
y�
z�
�revlogrr!�<lambda>��zslicechunk.<locals>.<lambda>)�maxrrrr�_slicechunktosize)r<�revs�
targetsize�densityslicing�chunk�subchunkrr;r!�
slicechunkMs�<





�
��rFccs�
�|d
usd|k
sJ�
|�|
d�
}|�
|
d�
}||}|d
us%||k
r*|
V
d
Sd}d}t|
�
}t|�

|D]6\}	}
|�
|
�
|}|�|
�
}||k
rS|rS|	d}nt||
||�}
|
r_|
V
|	}|�|
�
}|	d}|sn
n
q8t|
�
}|||kr�|}||dk
r�nL|�
|
|d�
}||}||kr�||dk
r�n|||d8}|�
|
|d�
}||}||ks�t||
||�}
|
r�|
V
|}|�|
|�
}|||ksyt||
|�}
|
r�|
V
d
Sd
S)aJslice revs to match the target size

    This is intended to be used on chunk that density slicing selected by that
    are still too large compared to the read garantee of revlog. This might
    happens when "minimal gap size" interrupted the slicing or when chain are
    built in a way that create large blocks next to each other.

    >>> data = [
    ...  3,  #0 (3)
    ...  5,  #1 (2)
    ...  6,  #2 (1)
    ...  8,  #3 (2)
    ...  8,  #4 (empty)
    ...  11, #5 (3)
    ...  12, #6 (1)
    ...  13, #7 (1)
    ...  14, #8 (1)
    ... ]

    == All snapshots cases ==
    >>> revlog = _testrevlog(data, snapshot=range(9))

    Cases where chunk is already small enough
    >>> list(_slicechunktosize(revlog, [0], 3))
    [[0]]
    >>> list(_slicechunktosize(revlog, [6, 7], 3))
    [[6, 7]]
    >>> list(_slicechunktosize(revlog, [0], None))
    [[0]]
    >>> list(_slicechunktosize(revlog, [6, 7], None))
    [[6, 7]]

    cases where we need actual slicing
    >>> list(_slicechunktosize(revlog, [0, 1], 3))
    [[0], [1]]
    >>> list(_slicechunktosize(revlog, [1, 3], 3))
    [[1], [3]]
    >>> list(_slicechunktosize(revlog, [1, 2, 3], 3))
    [[1, 2], [3]]
    >>> list(_slicechunktosize(revlog, [3, 5], 3))
    [[3], [5]]
    >>> list(_slicechunktosize(revlog, [3, 4, 5], 3))
    [[3], [5]]
    >>> list(_slicechunktosize(revlog, [5, 6, 7, 8], 3))
    [[5], [6, 7, 8]]
    >>> list(_slicechunktosize(revlog, [0, 1, 2, 3, 4, 5, 6, 7, 8], 3))
    [[0], [1, 2], [3], [5], [6, 7, 8]]

    Case with too large individual chunk (must return valid chunk)
    >>> list(_slicechunktosize(revlog, [0, 1], 2))
    [[0], [1]]
    >>> list(_slicechunktosize(revlog, [1, 3], 1))
    [[1], [3]]
    >>> list(_slicechunktosize(revlog, [3, 4, 5], 2))
    [[3], [5]]

    == No Snapshot cases ==
    >>> revlog = _testrevlog(data)

    Cases where chunk is already small enough
    >>> list(_slicechunktosize(revlog, [0], 3))
    [[0]]
    >>> list(_slicechunktosize(revlog, [6, 7], 3))
    [[6, 7]]
    >>> list(_slicechunktosize(revlog, [0], None))
    [[0]]
    >>> list(_slicechunktosize(revlog, [6, 7], None))
    [[6, 7]]

    cases where we need actual slicing
    >>> list(_slicechunktosize(revlog, [0, 1], 3))
    [[0], [1]]
    >>> list(_slicechunktosize(revlog, [1, 3], 3))
    [[1], [3]]
    >>> list(_slicechunktosize(revlog, [1, 2, 3], 3))
    [[1], [2, 3]]
    >>> list(_slicechunktosize(revlog, [3, 5], 3))
    [[3], [5]]
    >>> list(_slicechunktosize(revlog, [3, 4, 5], 3))
    [[3], [4, 5]]
    >>> list(_slicechunktosize(revlog, [5, 6, 7, 8], 3))
    [[5], [6, 7, 8]]
    >>> list(_slicechunktosize(revlog, [0, 1, 2, 3, 4, 5, 6, 7, 8], 3))
    [[0], [1, 2], [3], [5], [6, 7, 8]]

    Case with too large individual chunk (must return valid chunk)
    >>> list(_slicechunktosize(revlog, [0, 1], 2))
    [[0], [1]]
    >>> list(_slicechunktosize(revlog, [1, 3], 1))
    [[1], [3]]
    >>> list(_slicechunktosize(revlog, [3, 4, 5], 2))
    [[3], [5]]

    == mixed case ==
    >>> revlog = _testrevlog(data, snapshot=[0, 1, 2])
    >>> list(_slicechunktosize(revlog, list(range(9)), 5))
    [[0, 1], [2], [3, 4, 5], [6, 7, 8]]
    Nr
���rr)r'r)�	enumerate�nextr1�
_trimchunkr.)r<rArB�	startdata�enddata�fullspan�startrevidx�	endrevidx�iterrevs�idx�
r�spanr rD�nbitem�localenddatarrr!r@�sd�c






















�











�



�


�r@rc#s�
�|j}|j
�t|
�
d
k
r|
V
dSt||
�}||kr |
V
dS|}t�f
dd�|
D�
�
}|r6|t|�
}nd}||krA|
V
dSg}	d}
t|
�
D](\}}||�
}
�|�
}|dkrZqI|
du
rm|
|
}||krm|	�||f�

|
|}
qI|	��
g}|	r�||kr�|	�	�\}}|�|�

||8}|dkr�|t|�
}nd}|	r�||ks~|��
d}|D]}t
||
||�}|r�|V
|}q�t
||
|�}|r�|V
dSdS)a�slice revs to reduce the amount of unrelated data to be read from disk.

    ``revs`` is sliced into groups that should be read in one time.
    Assume that revs are sorted.

    The initial chunk is sliced until the overall density (payload/chunks-span
    ratio) is above `targetdensity`. No gap smaller than `mingapsize` is
    skipped.

    >>> revlog = _testrevlog([
    ...  5,  #00 (5)
    ...  10, #01 (5)
    ...  12, #02 (2)
    ...  12, #03 (empty)
    ...  27, #04 (15)
    ...  31, #05 (4)
    ...  31, #06 (empty)
    ...  42, #07 (11)
    ...  47, #08 (5)
    ...  47, #09 (empty)
    ...  48, #10 (1)
    ...  51, #11 (3)
    ...  74, #12 (23)
    ...  85, #13 (11)
    ...  86, #14 (1)
    ...  91, #15 (5)
    ... ])

    >>> list(_slicechunktodensity(revlog, list(range(16))))
    [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
    >>> list(_slicechunktodensity(revlog, [0, 15]))
    [[0], [15]]
    >>> list(_slicechunktodensity(revlog, [0, 11, 15]))
    [[0], [11], [15]]
    >>> list(_slicechunktodensity(revlog, [0, 11, 13, 15]))
    [[0], [11, 13, 15]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
    [[1, 2], [5, 8, 10, 11], [14]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
    ...                           mingapsize=20))
    [[1, 2, 3, 5, 8, 10, 11], [14]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
    ...                           targetdensity=0.95))
    [[1, 2], [5], [8, 10, 11], [14]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
    ...                           targetdensity=0.95, mingapsize=12))
    [[1, 2], [5, 8, 10, 11], [14]]
    rNc
3s�|]}
�|
�
V
qdSr+r��.0rR�
r-rr!�	<genexpr>q
s�z'_slicechunktodensity.<locals>.<genexpr>g�?r
)r'r-r.�segmentspan�sum�floatrH�append�sort�poprJ)r<rA�
targetdensity�
mingapsizer'�deltachainspan�readdata�chainpayloadr�gaps�prevend�
ir&�revstart�revlen�gapsize�selected�gapidx�previdxrQrDrrXr!r72
sf�1






















�





�r7cCs�|j}|d
urt
|
�
}|
|dt
|�
kr=|dkr=||kr=||
|d�
dkr=|d8}|dkr=||kr=||
|d�
dks'|
||�S)a�returns revs[startidx:endidx] without empty trailing revs

    Doctest Setup
    >>> revlog = _testrevlog([
    ...  5,  #0
    ...  10, #1
    ...  12, #2
    ...  12, #3 (empty)
    ...  17, #4
    ...  21, #5
    ...  21, #6 (empty)
    ... ])

    Contiguous cases:
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0)
    [0, 1, 2, 3, 4, 5]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 5)
    [0, 1, 2, 3, 4]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 4)
    [0, 1, 2]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 2, 4)
    [2]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3)
    [3, 4, 5]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3, 5)
    [3, 4]

    Discontiguous cases:
    >>> _trimchunk(revlog, [1, 3, 5, 6], 0)
    [1, 3, 5]
    >>> _trimchunk(revlog, [1, 3, 5, 6], 0, 2)
    [1]
    >>> _trimchunk(revlog, [1, 3, 5, 6], 1, 3)
    [3, 5]
    >>> _trimchunk(revlog, [1, 3, 5, 6], 1)
    [3, 5]
    Nrr
)r-r.)r<rA�startidx�endidxr-rrr!rJ�
s&
$$�rJcCs(|
sd
S|�|
d�
}||�
|
d
�
S)a�
Get the byte span of a segment of revisions

    revs is a sorted array of revision numbers

    >>> revlog = _testrevlog([
    ...  5,  #0
    ...  10, #1
    ...  12, #2
    ...  12, #3 (empty)
    ...  17, #4
    ... ])

    >>> segmentspan(revlog, [0, 1, 2, 3, 4])
    17
    >>> segmentspan(revlog, [0, 4])
    17
    >>> segmentspan(revlog, [3, 4])
    5
    >>> segmentspan(revlog, [1, 2, 3,])
    7
    >>> segmentspan(revlog, [1, 3])
    7
    r
rGr,)r<rAr)rrr!rZ�
s


rZcCs�t�
d
�
}|d|�t�|
�|�
t|�
|�kr||d�}	n
|
j||d�}
t�|
|�}	z"t�	|
|	|�}|r?|
j
|	|||d�
|t@rLt�
td�
|�
�
W|	Stjy^


|t@s[�Y|	Sw)z<build full text from a (base, delta) pair and other metadatas>lllN�
�_df)�p1�p2snode %s is not censored)�struct�calcsizer�replacediffheader�rawsizer.�revision�patchr�processflagsraw�	checkhashrr�StorageErrorr�CensoredNodeError)�fhr<�baserev�deltarrrs�flags�expectednode�hlen�fulltext�basetext�validatehashrrr!�_textfromdeltas.


�







���
��r�T)�slots�frozenc@sLeZ
dZe��Ze��Ze��Ze��Ze��Z	e��Z
e��Ze��Zd
S)�
_deltainfoN)
r2r3r4r�ib�distance�deltalenr�base�	chainbase�chainlen�compresseddeltalen�
snapshotdepthrrrr!r�#s






r�c

	CsN|jd
dksJ|jd
�
�
t
|j|jdd|jdf|j|j|j|j|j�S)z�turn into a "u" (no-compression) into no-compression without header

    This is useful for revlog format that has better compression method.
    r
�
ur�)	rr�r�r�r�r�r�r�r�)
r�rrr!�drop_u_compression/s








�r�cCs�|
d
urdS|j}|d}|j
}|s|
j}t||�}|js$||
jkr$dS||
jkr+dS|t|
jkr4dS|jr?|j|
j	kr?dS|
j
d
u
rN||
j
?|
jkrNdS|
j
r\|�|
j�
|
jkr\dSdS)z�Returns True if the given delta is good. Good means that it is within
    the disk span, disk size, and chain length bounds that we know to be
    performant.NF�T)
�textlen�_maxdeltachainspanr�r?�
_sparserevlogr��LIMIT_DELTA2TEXTr��_maxchainlenr�r�r-r�)r<�	deltainfo�revinfor��
defaultmax�maxdistrrr!�isgooddeltainfoAs0













�r�i�
ccs�
�t|�
r|j
s
d
V
d
S|j}|j}|j}d
}|
t}	th
}
t||||�}	|�|�
}|d
ur1n�g}
|D]�}|j	r^|tks^||
vs^||�
s^|
�
|�

||�
}|j	r^|tks^||
vs^||�
rF|tkrcq5||
vrhq5|
�
|�

|	|�|�
kruq5|r�|�|�
|
tkr�q5|�
|�
t@r�q5|�|�
\}}|jr�||jkr�q5|	|kr�q5|r�|jd
u
r�|j}||tf}||v
r�|�|�
r�|�|�
}|�|�
}t|
|d�}||}|
|?}||kr�q5|�|�
}||kr�q5|
�|�

q5|
r�t|
�
V}q'd
V
d
S)z�Provides group of revision to be tested as delta base

    This top level function focus on emitting groups with unique and worthwhile
    content. See _raw_candidate_groups for details about the group order.
    NTr
)r.�_storedeltachainsr-�deltaparentr�r�r�_refinedgroups�send�
_generaldelta�addrw�LIMIT_BASE2TEXTr�r
�
_chaininfor��upperboundcompr1r�r?r]�tuple)r<r�rrrs�
cachedelta�deltalengthr��sparse�good�deltas_limit�tested�
candidates�
temptative�groupr&r��	chainsize�maxcomp�basenotsnapr��revsize�rawsizedistance�lowestrealisticdeltalen�
snapshotlimit�	revlengthrrr!�_candidategroups�st�















�
























�
Fr�cCsZt�
|jd
�r|j�|
|�
dS|j}|j}|�|�
D]}||�
r*|
||�
�|�

qdS)z#find snapshot from start_rev to tips
findsnapshotsN)r�safehasattrr�
findsnapshotsr�r1rAr])r<�cache�	start_revr�r1r&rrr!�_findsnapshots�s




��r�c
cs
�d}|r|jr|j
r|d
f
V}|du
rdV
dSt�t�
}t||
|||�D]}|V}|du
r2
n
q'|js;dV
dS|du
r�||
|fv
r�|�|�
r�d}||krd|}|�|�
}|t	kr\n|f
V}||ksP|snt
|||d�
d}||kr�|}ttdd�||D�
�
�
}	|	V}||kstdV
dS)Nr
rc
ss�|]}
|
V
qdSr+r)rW�
crrr!rY#s�z!_refinedgroups.<locals>.<genexpr>)
r��_lazydeltabase�collections�defaultdict�list�
_rawgroupsr�r1r�rr�r��sorted)
r<rrrsr�r��	snapshotsr��previousr��childrenrrr!r��sD�









�








�





�
r�c#sX��j}|o�j
}t��
}|d
}�f
dd��|rEdd�|
|fD�
}	�js<t|	�
dkr<|	��
|	d
f
V
|	df
V
n	t|	�
dkrE|	V
|�
r!|	�
r!|durTt�t�
}t�t�
}
�f
d	d�|	D�
}|D]}t	|�
D]\}
}��
|�
su
n|
|
�|�

qjqdt|
d�
d
}t
�||�
t�}|D]}|�|�

q�d}��||�D]
}||v
r�|}
n
q�|du
r�t|
���
}�|�
}t	|�
D]\}
}||kr�q�||
kr�
n��
|�
s�
n|
|
�|�

q�d�
t|
��d
d�D]3\}
}t�}|D]	}|�||�

q�
du
�
r�
f
dd�|D�
}tt|�
�
V
tt|�
�
V
t|�
�
q�t|t�
V
|�
s*|f
V
dSdS)
z�Provides group of revision to be tested as delta base

    This lower level function focus on emitting delta theorically interresting
    without looking it any practical details.

    The group order aims at providing fast or small candidates first.
    rc

s��|�
d
Sr()
�_deltachain)
r&r;rr!r=7r>z_rawgroups.<locals>.<lambda>c
Ssg|]}
|
tkr|
�qSrr�rW�
prrr!�
<listcomp>;�z_rawgroups.<locals>.<listcomp>rr
Nc
sg|]}
�|
�
�qSrrr�)
�
deltachainrr!r�RsT)
�reversec
sg|]}
�|
kr|
�qSrrrV)
�floorrr!r��r�)r�r�r.�_deltabothparentsr^r�r�r�rrHr1r��minr��updaterAr?�keysr��itemsr�r)r<rrrsr�r��gdeltar��curr�prev�parents�
parents_snaps�candidate_chains�chainrQ�
s�	snapfloor�all_revs�otherrR�	max_depth�snaps�siblingsr)r�r�r<r!r�*sz�















�

	






�


















	�r�c@s>eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zddd
�
ZdS)�
deltacomputercCs
|
|_dSr+r;)rr<rrr!r"�r0zdeltacomputer.__init__c		Cs`|
j}|d
du
r
|d
S|j
}|
j}|d
}|d}t|||||
j|
j|
j|
j�}|d
<|S)z�Builds a fulltext version of a revision

        revinfo: revisioninfo instance that contains all needed info
        fh:      file handle to either the .i or the .d revlog file,
                 depending on whether it is inlined or not
        r
Nr)�btextr<r�r�rrrsr��node)	rr�r~r�r<r�rr�r�rrr!�	buildtext�s$












�
zdeltacomputer.buildtextc	Cs\|j}|�
||�}|�|
�
rt�|�|
�
t|�
�}||}|S|j|
|d
�}t�||�}|S)Nrp)	r<r��
iscensoredrrvrwr.�rawdata�textdiff)	rr�r�r~r<�
t�headerr��ptextrrr!�_builddeltadiff�s




�
zdeltacomputer._builddeltadiffc	Cs�
|j}|�
|�
}|jr|}n|}d}|jr|tkrd
}n)|jrE|�|�
rE|�|
j�
|�|
j�
}}	|||	fv
rE|�|�
rEt	|�
|�
d
�
}d}
|
jr�|
j\}}|}
|
tkrw|
|krw|j�|
�
d
krw|j�
|
�
}
|
tkrw|
|krw|j�|
�
d
ksa|jjr�|
|kr�|
jd}
|
dur�|�||
|�}
|jdu
r�|r�t	|
�
|j}|
j|?}||kr�dS|�|�
|kr�dS|�|
�
\}}t	|�
t	|�
}|�t	|�
d�
}|||�|�
}|�|�
\}}|d7}||7}t||||f|||||�Sr#)r<r�r�r�rr1r&rrrsr.r�r�r-r��
_lazydeltar�r�r��compressr)r'r�r�)rr�r�r~r<r��	deltabaser�rrrsr��	cachebase�	cachediff�currentbaser�r�r�rr��offset�distr�r�rrr!�_builddeltainfo�sf















�



























�zdeltacomputer._builddeltainfoc
	Cs^|�||
�}|j
�|�
}t|d
�
t|d�
}}}|}	}
d}d
}t||||	|
|||�S)Nrr
)r�r<r�r.r�)
rr~r�r��rawtextrr�r�r�r�r�r�r�rrr!�_fullsnapshotinfos 

 











�zdeltacomputer._fullsnapshotinfoNcCsX
|d
ur	t|j
�
}|
js|�||
|�S|d
urt�}|
jt@r&|�||
|�S|
j}|
j}|
j	}|j
}d
}	|�
|�
|�
|�
}
}t|j
|
j|
||�}t|�
}
|
d
u
r�g}|	d
u
r\|�
|	�

|
D]#}||vreq^||krjq^|�|
||�}|d
u
r�t|j
||
�r�|�
|�

q^|r�t|dd�d�}	|	d
u
r�|�|	j�
}
nt|�
}
|
d
u
sQ|	d
ur�|�||
|�}	|	S)ayFind an acceptable delta against a candidate revision

        revinfo: information about the revision (instance of _revisioninfo)
        fh:      file handle to either the .i or the .d revlog file,
                 depending on whether it is inlined or not

        Returns the first acceptable candidate revision, as ordered by
        _candidategroups

        If no suitable deltabase is found, we return delta info for a full
        snapshot.

        `excluded_bases` is an optional set of revision that cannot be used as
        a delta base. Use this to recompute delta suitable in censor or strip
        context.
        Nc


Ss|jSr+)
r�)
r8rrr!r=Zsz-deltacomputer.finddeltainfo.<locals>.<lambda>)
�key)r.r<r�r�rr�r
r�rrrsr&r�rIr]r�r�r�r�r�)rr�r~�excluded_bases�
target_revr�rrrsr<r��p1r�p2r�groups�
candidaterevs�nominateddeltas�candidaterev�candidatedeltarrr!�
finddeltainfosR











�













�



�

zdeltacomputer.finddeltainfo)NN)	r2r3r4r"r�r�r�r�r
rrrr!r��s
;r�cCsz|
j\}}t
}|s|st}||
fS|s-|d
d�}|dkr#t}||
fS||kr)t}||
fS|dkr9d}t}t|
�
}
||
fS)zreturn (COMPRESSION_MODE, deltainfo)

    used by revlog v2+ format to dispatch between PLAIN and DEFAULT
    compression.
    r
r�
r�r�)rr
rr	r�)�default_compression_headerr��
h�
d�compression_moder�rrr!�delta_compressiones$


�


�
�


r

r+)rr
),r5�
__future__rr�rtr�r�i18nr�pycompatr�	constantsr	r
rrr
�
thirdpartyr�rrrrr��objectrrFr@r7rJrZr�r�r�r�r�r�r�r�r�r�r�r

rrrr!�<module>
s@



#
J

~6
L]
1yC