HEX
Server: Apache
System: Linux pdx1-shared-a1-38 6.6.104-grsec-jammy+ #3 SMP Tue Sep 16 00:28:11 UTC 2025 x86_64
User: mmickelson (3396398)
PHP: 8.1.31
Disabled: NONE
$ pwd: /usr/lib/python3/dist-packages/mercurial/__pycache__/
Upload Files
File: //usr/lib/python3/dist-packages/mercurial/__pycache__/merge.cpython-310.pyc
o

�]Lb\h�@sddlmZddlZddlZddlZddlmZddlmZddl	m
Z
ddlmZddl
mZdd	lmZmZmZmZmZmZmZmZmZmZmZmZmZmZej Z!ej"Z#d
d�Z$dIdd
�Z%Gdd�de&�Z'dd�Z(dd�Z)dd�Z*dd�Z+dd�Z,dd�Z-Gdd�de&�Z.	dJdd �Z/d!d"�Z0		dKd#d$�Z1d%d&�Z2d'd(�Z3d)d*�Z4d+d,�Z5e
j6d-d.�Gd/d0�d0e&��Z7	dId1d2�Z8d3d4�Z9d5Z:d6Z;d7Z<d8Z=						-		dLd9d:�Z>dMd;d<�Z?dNd=d>�Z@dId?d@�ZAdNdAdB�ZB					dOdCdD�ZCdNdEdF�ZD	-		-	-			dPdGdH�ZEdS)Q�)�absolute_importN�)�_)�nullrev)�attr)�
stringutil)�	timestamp)�copies�encoding�error�	filemerge�match�
mergestate�obsutil�pathutil�policy�pycompat�scmutil�subrepoutil�util�workercCsX|j�||�}gd�}||vr*d�dd�|D��}td�}|||||f;}t�|��|S)N)�abortsignore�warns, cSsg|]}d|d�qS)�'�)�.0�vrr�1/usr/lib/python3/dist-packages/mercurial/merge.py�
<listcomp>,sz*_getcheckunknownconfig.<locals>.<listcomp>s$%s.%s not valid ('%s' is none of %s))�ui�config�joinrr�ConfigError)�repo�section�namer �valid�validstr�msgrrr�_getcheckunknownconfig(s
r)cCsV|��rdS|dur|}|jj�|�o*|j�|�o*|j�|�|jvo*||�||�S�NF)�
isinmemory�wvfs�audit�check�isfileorlink�dirstate�	normalize�cmp)r#�wctx�mctx�f�f2rrr�_checkunknownfile3s
���r7c@s eZdZdZdd�Zdd�ZdS)�_unknowndirscheckeray
    Look for any unknown files or directories that may have a path conflict
    with a file.  If any path prefix of the file exists as a file or link,
    then it conflicts.  If the file itself is a directory that contains any
    file that is not tracked, then it conflicts.

    Returns the shortest path at which a conflict occurs, or None if there is
    no conflict.
    cCst�|_t�|_dS�N)�set�_unknowndircache�_missingdircache��selfrrr�__init__Qsz_unknowndirschecker.__init__c	Cs|��rdSttt�|���D]?}||jvrdS||jvrq|jj�	|�rN|j�
|�r9|j�|�|jvr9|S|j�
|�sH|j�|�dS|j�|�q|jj�	|�r�|j�|�r�|j�|�D]'\}}}|D]}t�|j�||��}|jj|dd�}||jvr�|SqiqbdS)NFT)�isknown)r+�reversed�listr�finddirsr<r;r,r-r.r/r0r1�lexists�add�isdir�walkr�pconvert�reljoin)	r>r#r3r5�p�dirs�files�fn�relfrrr�__call__\s6


��
��z_unknowndirschecker.__call__N)�__name__�
__module__�__qualname__�__doc__r?rOrrrrr8Fs
r8c
st�}t��t��t��t�dd�}t�dd�}�j�dd�}	|s���fdd�}
t�}|�tjtjf�D]$}t	�|||�rC|�
|�q4|	rX||vrX|�||�}
|
durX��
|
�q4|�tjg�D]\}}}t	�||||d	�rt|�
|�q`|�B}�fd
d�|D�}||}|
||�|
||�nft
|�tjg��D]\\}}}|\}}t	�|||�}�j�|�r�|}n|}|s�|�|tj|dfd
�q�|s�|dkr�|�|tj||dd|fd�q�|dkr��
|�q�|dkr��
|�|�|tj|dfd
�q�t��D],}�jj}|�v�r�j�|��r|td�|�q�|td�|�q�|td�|�q���r2t�td���t��D] }�j�|��rK�j�td�|��q6�j�td�|��q6t
|�tjg��D],\}}}||v�p||�v�p|t�fdd�t�|�D��}|\}|�|tj||f|��q`dS)z�
    Considers any actions that care about the presence of conflicting unknown
    files. For some actions, the result is to abort; for others, it is to
    choose a different action.
    �mergescheckunknownscheckignored�experimental�merge.checkpathconflictscs0|dkr��|�dS|dkr��|�dSdS)Nrr)�update)�	conflictsr )�abortconflicts�
warnconflictsrr�collectconflicts�s
�z,_checkunknownfiles.<locals>.collectconflictsNrcsh|]
}�j�|�r|�qSr)r0�_ignore)r�c�r#rr�	<setcomp>�sz%_checkunknownfiles.<locals>.<setcomp>F�remote createdrs#remote differs from untracked localrTs,%s: untracked file conflicts with directory
s,%s: untracked directory conflicts with file
s%s: untracked file differs
sLuntracked files in working directory differ from files in requested revisions%s: replacing untracked file
s+%s: replacing untracked files in directory
c3s�|]}|�vVqdSr9r)rrJ)�
pathconflictsrr�	<genexpr>���z%_checkunknownfiles.<locals>.<genexpr>)r:r)r�
configboolr8rL�
mergestatemod�ACTION_CREATED�ACTION_DELETED_CHANGEDr7rE�
getactions�ACTION_LOCAL_DIR_RENAME_GETrB�ACTION_CREATED_MERGEr0r\�addfile�
ACTION_GET�ACTION_MERGE�sorted�warnr,r/rr�
StateError�anyrrC)r#r3r4�force�mresult�
mergeforce�
fileconflicts�
unknownconfig�
ignoredconfig�
pathconfigr[�checkunknowndirsr5�path�argsr(�allconflicts�ignoredconflicts�unknownconflicts�fl2�anc�	differentr ro�backup�flagsr)rYrar#rZr�_checkunknownfiles~s����
��
�
���
�
���
���r�cCsjtj}|rtj}|��D]}||vr|�||dd�q|s1|��D]}||vr0|�|tjdd�q!dSdS)a�
    Forget removed files

    If we're jumping between revisions (as opposed to merging), and if
    neither the working directory nor the target rev has the file,
    then we need to remove it from the dirstate, to prevent the
    dirstate from listing the file when it is no longer in the
    manifest.

    If we're merging, and the other revision has removed a file
    that is not present in the working directory, we need to mark it
    as removed.
    Nsforget deletedsforget removed)re�
ACTION_FORGET�
ACTION_REMOVE�deletedrk�removed)r3r4�branchmergers�mr5rrr�_forgetremoveds&����r�cCs�|��}|��s$t|�|��}|r#t|���D]}||�s"|�|�qnt|�}|r�|�tjtj	tj
tjtjtj
f�D]}|�|�q;|�tjf�D]}|�|�qJ|�tjg�D]\}}}|\}}	|�|�|�|�qY|�tjf�D]}|�|�qt|�tjg�D]\}}}|\}
}}}}
|r�|�|
�|�|�q�i}|D] }t�|�}||vr�td�}||||f;}t�|��|||<q�d}}}t|���D]'\}}|�|�r�|�|�s�td�}|||f;}t�|��|d}|d}|}q�dS)z,
    Check for case-folding collisions.
    s(case-folding collision between %s and %s�s5case-folding collision between %s and directory of %s�/N)�narrowmatch�alwaysr:rGrBrL�
removefilere�
ACTION_ADD�ACTION_ADD_MODIFIEDr�rl�ACTION_CHANGED_DELETEDrgrEr��discardrh�ACTION_DIR_RENAME_MOVE_LOCALrirmr�normcaserrrprn�items�
startswith)r#�wmfrsr��pmmfr5r{r(r6r��f1�fa�mover��foldmap�fold�
foldprefix�unfoldprefix�lastfullrrr�_checkcollision"sj
���
�





�r�ccs6�|D]}t�|�D]
}||vr||fVnq
qdS)z�
    Generator that yields pairs of all the files in the manifest that are found
    inside the directories listed in dirs, and which directory they are found
    in.
    N)rrC)r#�manifestrKr5rJrrr�_filesindirsfs�
���r�c	Cs�|��}t�}t�}t�}t�}t�}	|�tjtjtjtjf�D]}
|�t	�
|
��|�|
�r4|�|
�q |�tj
f�D]}
|	�|
�q<|�tjf�D]\}
}}|\}
}}}}|r^|	�|
�qK|�tjf�D]\}
}}|\}}|	�|�qf|D]/}||vr�||vr�|�|�n|�|�|�|�}|r�|dtjtjtjtjfvr�|�|�qw|D]7}||	vr�t|��d�}t�|||t|����}||��p�|}|�|tj||fd�|�|tj|dfd�q�|�rBt|��d�}t|||�D]P\}
}|
|	v�rA|�|�\}}}t�|||t|����}|tjtjfv�r |�||||�n|d}|�|tj||fd�|�|tj|dfd�|�|�nq�|�r\|D]
}|j�td�|��qGt� td	���d
S)z�
    Check if any actions introduce path conflicts in the repository, updating
    actions to record or handle the path conflict accordingly.
    r�+slocal path conflict�ls
path conflictsremote path conflict�rs#%s: is both a file and a directory
s,destination manifest contains path conflictsN)!r�r:rLrerfrgrmrjrWrrC�hasdirrEr�rhr��getfile�bytes�rstripr�safename�
copysourcerk�ACTION_PATH_CONFLICT_RESOLVE�ACTION_PATH_CONFLICTr�ri�removerrorrrp)r#r3r4rs�mf�localconflicts�remoteconflicts�invalidconflicts�createdfiledirs�deletedfilesr5r{r(r�r6r�r�r�r�rJ�pd�ctxname�pnew�porigr��flrrr�checkpathconflictsss���	

�
��


�
	����
���
���r�cCs�|��D]Q\}}||�r
q|s|�|�q|djr |�|�q|djrK|�d�s:|�|�|�|d|dj�qtd�}td�}tj	|||d��td�}t�
||��dS)	z�
    Filters out actions that can ignored because the repo is narrowed.

    Raise an exception if the merge cannot be completed because the repo is
    narrowed.
    rr�soutside-narrow-merge-actionsBmerge affects file '%s' outside narrow, which is not yet supporteds'merging in the other direction may work��hints-conflict in file '%s' is outside narrow cloneN)�filemapr��no_op�narrow_safe�endswith�
addcommitinfo�changesrr�Abortrp)r�r�rsr5�actionr(r�rrr�_filternarrowactions�s*	



���r�c@s�eZdZdZdd�Zdd�Zdd�Zd$d	d
�Zd$dd�Zd
d�Z	d%dd�Z
d$dd�Zd%dd�Zdd�Z
edd��Zedd��Zedd��Zedd��Zd d!�Zd"d#�ZdS)&�mergeresultz�An object representing result of merging manifests.

    It has information about what actions need to be performed on dirstate
    mapping of divergent renames and other such cases.cCs.i|_i|_i|_t�t�|_t�t�|_dS)aY
        filemapping: dict of filename as keys and action related info as values
        diverge: mapping of source name -> list of dest name for
                 divergent renames
        renamedelete: mapping of source name -> list of destinations for files
                      deleted on one side and renamed on other.
        commitinfo: dict containing data which should be used on commit
                    contains a filename -> info mapping
        actionmapping: dict of action names as keys and values are dict of
                       filename as key and related data as values
        N)�_filemapping�_diverge�
_renamedelete�collections�defaultdict�dict�_commitinfo�_actionmappingr=rrrr?#s
zmergeresult.__init__cCs||_||_dSr9)r�r�)r>�diverge�renamedeleterrr�updatevalues5s
zmergeresult.updatevaluescCsL||jvr|j|\}}}|j||=|||f|j|<||f|j||<dS)aadds a new file to the mergeresult object

        filename: file which we are adding
        action: one of mergestatemod.ACTION_*
        data: a tuple of information like fctx and ctx related to this merge
        message: a message about the merge
        N�r�r�)r>�filenamer��data�message�a�dr�rrrrk9s


zmergeresult.addfileNcCs||jvr
|j|S|S)zfreturns (action, args, msg) about this file

        returns default_return if the file is not present)r�)r>r��default_returnrrrr�Js

zmergeresult.getfileccsD�|dur|jD]}|VqdS|D]
}|j|D]}|VqqdS)zvreturns files on which provided action needs to perfromed

        If actions is None, all files are returned
        Nr�)r>�actionsr5r�rrrrLRs�
���zmergeresult.filescCs(|j|\}}}|j|=|j||=dS)zXremoves a file from the mergeresult object as the file might
        not merging anymoreNr�)r>r�r�r�r�rrrr�bszmergeresult.removefileFccsr�|D]3}|r!t|j|�D]}|j||\}}|||fVqqt�|j|�D]\}\}}|||fVq)qdS)z�get list of files which are marked with these actions
        if sort is true, files for each action is sorted and then added

        Returns a list of tuple of form (filename, data, message)
        N)rnr�r�	iteritems)r>r��sortr�r5r{r(rrrrhis�����zmergeresult.getactionscs(|dur	t�j�St�fdd�|D��S)z�returns number of files which needs actions

        if actions is passed, total of number of files in that action
        only is returnedNc3s�|]
}t�j|�VqdSr9)�lenr��rr�r=rrrb���z"mergeresult.len.<locals>.<genexpr>)r�r��sum)r>r�rr=rr�zs
zmergeresult.lenccsR�trtt�|j��D]	\}}||fVqdSt�|j�D]	\}}||fVqdSr9)rnrr�r�)r>r��key�valrrrr��s���zmergeresult.filemapcCs||j||<dS)zdadds key-value information about filename which will be required
        while committing this mergeN�r�)r>r�r��valuerrrr��szmergeresult.addcommitinfocC�|jSr9)r�r=rrrr���zmergeresult.divergecCr�r9)r�r=rrrr��r�zmergeresult.renamedeletecCr�r9r�r=rrr�
commitinfo�r�zmergeresult.commitinfocCsPt�t�}t�|j�D]\}}t�|�D]\}\}}||�|||f�qq|S)z}returns a dictionary of actions to be perfomed with action as key
        and a list of files and related arguments as values)r�r�rBrr�r��append)r>�resr�r�r5r{r(rrr�actionsdict�s
�zmergeresult.actionsdictcCsD||_t�t�|_t�|j�D]\}\}}}||f|j||<qdSr9)r�r�r�r�r�rr�)r>r�r5�actr�r(rrr�
setactions�s
�zmergeresult.setactionscCsB|j��D]}|tjtjtjtjfvr|j|r|jsdSqdS)z^tells whether this merge resulted in some actions which can
        result in conflicts or notTF)r��keysrerl�ACTION_EXECr�r�r�)r>r�rrr�hasconflicts�s����
�zmergeresult.hasconflictsr9�F)rPrQrRrSr?r�rkr�rLr�rhr�r�r��propertyr�r�r�r�r�r�rrrrr�s,








	r�Fc
,s�t�}
|dur
|��r
d}dd�t���||gtjd�D�t��}t��}i}
|r6t�|�||�\}}}
t	�
t|��}t	�
t|��}t	�
t|��}|j�
td��|j�d|||f�|j�d|�|f����|��|��}}}t|j���}|�|j���t|j���}|�|j���d|vr����dur�t�fd	d
��jD��r�|jj|d<|�|g���vr�|	s�|j�dd�s�|jd
ks�t|�|����}t	�|j�D]
\}}||vr�|� |�q�|jD]}|� |�q�t�!||�}t"�#||�}|j||d�}t	�|�D�]\}\\}}\}} |�r6|�r6||v�r[|j�$|d��p-|j�$|d�}!d\}"}#|!du�rE|||!d|�%�f}"d|!}#n||dd|�%�f}"d}#|
�&|t'j(|"|#��q	||jv�rz|j|}!|
�&|t'j(||!|!d|�%�fd|!��q	||jv�r�|j|}!|
�&|t'j(|!||!d|�%�fd|!��q	||}$|�)|�}%d|| |%v}&||$k�r�| |%k�r�|
�&|t'j*dd��q	||$k�r�||%k�r�||k�r�|
�&|t'j+| fd��q	|
�&|t'j,| dfd�|�r�|
�-|dd��q	|&�r||$k�r|
�&|t'j+| fd��q	|&�r$||$k�r$|
�&|t'j,|dfd�|�r"|
�-|dd��q	|
�&|t'j(|||d|�%�fd��q	|�r�||v�r@�q	||jv�rq|j|}'|'|v�rb|
�&|'t'j(||'dd|�%�fd��q	|
�&|'t'j.||fd|��q	||jv�r�|j|}'|
�&|t'j(||'|'d|�%�fd |'��q	||v�r�|||k�r�|�r�|
�&|t'j/dd!��q	|
�&|t'j0|d|d|�%�fd"�|�r�|
�-|d#d$��q	||jj1k�r�|
�&|t'j2dd%��q	|
�&|t'j/dd&�|�r�|
�-|d#d$��q	|
�&|t'j3dd'��q	|�r ||v�r�q	||jv�r3|j|}'|'|v�r$|
�&|'t'j(|'|dd|�%�fd(��q	|
�&|'t'j4|| fd)|��q	||jv�rm|j|}'d\}#}"|'|v�rU|'||'d|�%�f}"d*|'}#n
|'||'d|�%�f}"d+|'}#|
�&|t'j(|"|#��q	||v�r�|�s�|
�&|t'j5| fd,��q	|�s�|
�&|t'j5| fd,��q	|
�&|t'j6| |�%�fd-��q	|||k�r
d}(|j7D]})|�8|)��r�|j7|)|t9|)�d�}(n�q�|(du�r�|(|v�r�|
�&|(t'j(|(||d|�%�fd.|��q	|�r�|
�&|t'j5| fd/��q	|
�&|t'j:d||d|�%�fd0�|�r|
�-|d#d$��q	|
�&|t'j;dd1�|�r |
�-|d#d$��q	|j�dd2��r1t<|�||
�|�=�}*|*���s@t>|*||
�|j?}+|+�|j?�|
�@|
|+�|
S)3a
    Merge wctx and p2 with ancestor pa and generate merge action list

    branchmerge and force are as passed in to update
    matcher = matcher to filter file lists
    acceptremote = accept the incoming changes without prompting

    Returns an object of mergeresult class
    NcSsg|]}|���qSr)r�)r�xrrrr�s��z!manifestmerge.<locals>.<listcomp>)r�sresolving manifests
s) branchmerge: %s, force: %s, partial: %s
s% ancestor: %s, local: %s, remote: %s
�.hgsubstatec3s�|]
}��|���VqdSr9)�sub�dirty)r�s�r3rrrb�r�z manifestmerge.<locals>.<genexpr>rUsmerge-track-salvagedschangeset-sidedata)r
�NNFsboth renamed from %ssboth createdslocal replaced from %ssother replaced from %sr�rsremote unchangedsupdate permissionssremote is newersfilenode-sourcesothersversions differTs%remote directory rename, both createds&remote directory rename - move from %sslocal copied/moved from %ss
remote deletesprompt changed/deletedsmerge-removal-candidate�yessremote deleteds
other deleteds ancestor missing, remote missings$local directory rename, both createds$local directory rename - get from %ssremote copied from %ssremote moved from %sr`sremote created, get or merges-local directory rename - respect move from %ssremote recreatingsprompt deleted/changeds#local not present, remote unchangedrV)Ar�r�rn�parentsr�intrevr	�
branch_copies�mergecopiesr�bytestr�boolr�noter�debugr�r:�copy�valuesrW�movewithdir�revrq�substate�
nodeconstants�modifiednodeidrd�filecopiesmode�diffr�r�rE�
matchfiles�matchmod�intersectmatchers�get�noderkrermr��ACTION_KEEPr�rlr�r�r�r��addednodeidr��ACTION_KEEP_NEWrirfrj�dirmover�r�rg�ACTION_KEEP_ABSENTr�r�r�r�r�),r#r3�p2�par�rr�matcher�acceptremote�followcopies�
forcefulldiffrs�branch_copies1�branch_copies2r��boolbm�boolf�boolm�m1�m2�ma�copied1�copied2�
relevantfiles�copykey�	copyvalue�
movedirkey�filesmatcherrr5�n1�fl1�n2rr�r{r(r��fla�nolr6�dfr�r�r�rr�r�
manifestmerge�sT�
��	��

�
 
��


�
�
�
��������


��
�
���������


��



��
�
���������
r2cCs�t|�tjf��D]}||vr!||�||�s!|�|tjdd�q	t|�tjf��D]}||vr?||�||�s?|�|�q+dS)zXResolves false conflicts where the nodeid changed but the content
    remained the same.Nsprompt same)	rBrLrer�r2rkr�rgr�)r#r3r4�ancestorrsr5rrr�_resolvetrivialCs
��
��r4c

sXddlm}
d}t|�dkr't||||d|||||�	}t||||||	��nb|j�td�||td��dd�|D��f�i}t	�}d	\}
}|D]�}|j�td
�|�t|||||||||dd�
}t||||||	�|
dusyt|j
�t|
�kr||j
}
|dus�t|�t|j�kr�|j}|j�
|j�|jdd
�D]7\}}|\}}}|j�d|||��f�||vr�||}||vr�||�|�q�|g||<q�||gi||<q�qI|j�td�t|��t|���D�]�\}}|jj�r|j�d|�t|���D]\}��D]\}}}|j�d||��f��qq�t|�dk�rQt|���d\}�t�fdd��dd�D���rQ|j�td�||��f�|j|g�d�R�q�tj|v�rp|j�td�|�|j|g|tjd�R�q�tj|v�r�|j�td�|�|j|g|tjd�R�q�tj|v�r�tj|v�r�|j�td�|�|j|g|tjd�R�q�tj|v�r�|j�td�|�|j|g|tjd�R�q�tj|v�r�tj|v�r�|j�td�|�|j|g|tjd�R�q�tj|v�r,|tjd�t�fdd�|tjdd�D���r,|j�td�|�|j|g��R�q�|j�td�|�t|���D]\}��D]\}}}|j�d||��f��qB�q<t|���d\}�|j�td�||��f�|j|g�d�R�q�|j�td��|� |
|�|�!�du�r�t"||||�|
�#|||||�t$||||d|�|S)a�
    Calculate the actions needed to merge mctx into wctx using ancestors

    Uses manifestmerge() to merge manifest and get list of actions required to
    perform for merging two manifests. If there are multiple ancestors, uses bid
    merge if enabled.

    Also filters out actions which are unrequired if repository is sparse.

    Returns mergeresult object same as manifestmerge().
    r��sparseNrs5note: merging %s and %s using bids from ancestors %s
s and css�|]}t�|�VqdSr9)rr�rr�rrrrb�s�z#calculateupdates.<locals>.<genexpr>r�s"
calculating bids for ancestor %s
T)r�r�� %s: %s -> %s
s/
auction for merging merge bids (%d ancestors)
s list of bids for %s:
s   %s -> %s
c3s�|]	}|�dkVqdS)rNrr�)�lrrrb�s�s %s: consensus for %s
s %s: picking 'keep' action
s" %s: picking 'keep absent' action
s& %s: picking 'changed/deleted' action
s %s: picking 'keep new' action
s% %s: picking 'delete/changed' action
c3s�|]}|�kVqdSr9rr�)�ga0rrrb�rcs %s: picking 'get' action
s% %s: multiple bids for merge action:
s  %s -> %s
s( %s: ambiguous merge - picked %s action
send of auction

)%�r6r�r2r�rrrr!r�r�r�r�rWr�r�	__bytes__r�rnr��	debugflagrB�allrkrerrr�rrgrlror�rr��filterupdatesactionsr4)r#r3r4�	ancestorsr�rrrrrrtr6rs�fbidsr�r�r3�mresult1r5r�r�r{r(r��bids�_fr)r;r:r�calculateupdatesUs������
���
� �����&�
��rFc
Cs@zt��WSty}z|jtjkrWYd}~dS�d}~wwr9)r
�getcwd�OSError�errno�ENOENT)�errrrr�_getcwds
��rLc
cs�|jj}t�}d}|D]]\}}}|j�d||f�|r'|j�td�|�||��z
||jdd�Wn"tyY}	z|j�	td�|t
�|	j�f�WYd}	~	nd}	~	ww|dkre||fVd}|d	7}q|dkrs||fV|r�t�s�|j�	td
�|j
�dSdSdS)zSapply removes to the working directory

    yields tuples for progress updates
    rs
 %s: %s -> r
�removing %s
T)�
ignoremissings update failed to remove %s: %s!
N�drsCcurrent directory was removed
(consider changing to repo root: %s)
)r�verboserLrrrr-r�rHror�forcebytestr�strerror�root)
r#r3r�rP�cwd�ir5r{r(�instrrr�batchremove&sD�����



����rWccs��i}|jj}|j}|j}d}	|jj|t|�d���|D]�\}
\}}}
|j�d|
|
f�|r9|j�td�|
�|rk|
}|j�	|
�sUt
�|
�D]}|j�|�rT|}nqH|j�	|�rkt
�|||�}t�|�|�|�||
}|��|�dd�}|j||
���|d|d�}|r�|��}|j}t�|�}|||f||
<|	d	kr�d
|	|
ffVd}	|	d7}	qWd�n1s�wY|	dkr�d
|	|
ffVd|fVdS)
ajapply gets to the working directory

    mctx is the context to get from

    Yields arbitrarily many (False, tuple) for progress updates, followed by
    exactly one (True, filedata). When wantfiledata is false, filedata is an
    empty dict. When wantfiledata is true, filedata[f] is a triple (mode, size,
    mtime) of the file f written for each action.
    r)�
expectedcounts
 %s: %s -> g
sgetting %s
rUsupdate.atomic-fileT)�backgroundclose�
atomictemprOFrN)rrP�filectxr,�backgroundclosingr�rrrrDrrCr/r�
backuppathr�rename�wjoin�clearunknownrd�writer��lstat�st_moder�mtime_of)r#r4r3�wantfiledatar��filedatarP�fctxrrUr5r�r�r(�conflictingrJ�orig�wfctxrZ�sizer��mode�mtimerrr�batchgetMsZ�
�
�

��BrncCsD|�tjtjtjtjg�}tj}tj}|||�	�|||�fg�dS)z�Invoke ``scmutil.prefetchfiles()`` for the files relevant to the dict
    of merge actions.  ``ctx`` is the context being merged in.N)
rLrerlrgrirmr�
prefetchfilesr
r)r#�ctxrsrL�prefetchr
rrr�_prefetchfiles�s ��	���rrT)�frozenc@s4eZdZe��Ze��Ze��Ze��Zdd�Z	dS)�updateresultcCs|jp|jp|jp|jSr9)�updatedcount�mergedcount�removedcount�unresolvedcountr=rrr�isempty�s���zupdateresult.isemptyN)
rPrQrRr�ibrurvrwrxryrrrrrt�srtc0Cs�t|||�d\}}}	|jdd�}
|
�|����|��|�t�|j�D]
\}}|
�||�q$|�	t
jj�}
|�	�|
}|j
jtd�td�|d�}d|jt
jvr[t�||||||�|jt
jgdd�D]?\}}}|\}}|j
j}|td	�|�|d
kr�|td�|�n|td�|�|td
�|�|
�|||�|j|d�qd|��r�dnd}t�|j
|t||ft|jt
jgdd���}|D]\}}|j||d�q�|�	t
jf�}	|jt
jgdd�D]J\}}}|j
�d||f�|\}}||���r#|j
� td�||f�||�!�||�"|�#|��$�|�#|��%��||�&�|j|d�q�|j
�'dd�}tj|j
|t(||||ft|jt
j)gdd��|dd�}i}|D]\}}|�rZ|}�qO|\}}|j||d��qOd|jt
j)v�rzt�||||||�|jt
j*fdd�D]\}}}|j
�d||f�|j|d��q�|jt
j+fdd�D]\}}}|j
�d||f�|j|d��q�|jt
j,fdd�D]\}}}|j
�d||f�|j|d��q�t
jjD]}|j|fdd�D]\}}}|j
�d|||�-�f��q�q�|jt
j.fdd�D]?\}}}|j
�d||f�|j|d�|\}} |j
� td�||f�||�!�||�"|�#|��$�| �||�&��q|jt
j/fdd�D]3\}}}|j
�d||f�|j|d�|\}} |j
� td�||f�||�"|�#|��$�| ��qP|jt
j0fdd�D]+\}}}|j
�d||f�|j|d�|\} ||�!�||�1d
| vd| v��q�g}!t|jt
j2t
j3t
j4gdd��}"|"D]h\}}}|\}}#}$}%}&|dk�rߐq�|d u�r�t5�6||$�}'n|j
�d!||f�||}'|#d u�rt5�6||$�}(n||#}(||&})|$|)v�r|)|$}*n|j#|t7d"�}*|
�8|'|(|*|�||k�r3|%�r3|!�9|��q�|!D]}||���rT|j
�d#|�||�!�||�&��q7|�	t
j)t
j0t
j/t
j.f�}zUzC|"D]>\}}}|j
�d$||f�|
�|d%d&i�|j|d�|dk�r�t�||||�:|�||��qg||�!�|
�;||��qgWnt<j=�y�YnwW|
�>�n|
�>�w|
�?�}+|
�@�\},}-}.||,7}||-7}|	|.7}	|
�A�}/|�B�tC|||	|+�||/fS)'a�apply the merge action list to the working directory

    mresult is a mergeresult object representing result of the merge
    wctx is the working copy context
    mctx is the context to be merged into the working copy

    Return a tuple of (counts, filedata), where counts is a tuple
    (updated, merged, removed, unresolved) that describes how many
    files were affected by the update, and filedata is as described in
    batchget.
    )rrrT)�cleansupdatingsfiles)�unit�totalr�r8sD%s: path conflict - a file or link has the same name as a directory
r�s&the local file has been renamed to %s
s'the remote file has been renamed to %s
s1resolve manually then use 'hg resolve --mark %s'
)�itemrg����MbP?)�stepr~s %s: %s -> pr
smoving %s to %s
rUsworker.wdir-get-thread-safe)�
threadsafe�	hasretvals
 %s: %s -> f
s
 %s: %s -> a
s %s: %s -> am
r9s %s: %s -> dm
s %s: %s -> dg
sgetting %s to %s
s
 %s: %s -> e
�xNs! preserving %s for resolve of %s
)�fileidrMs
 %s: %s -> m
smergedr�)Drrr�start�p1rrr�r�r�r�re�MergeAction�
NO_OP_ACTIONSr�makeprogressrr�r�r�submergerhr��status�addpathconflict�	incrementr+rrWrBr�rrDrr-rar[r�r�r�rdrnrlr�r�r�r=r�rir��setflagsr�rgrmr�
absentfilectxrrEr�r3�resolver�InterventionRequired�commitrx�countsr��completert)0r#rsr3r4�	overwritere�labels�updated�mergedr��msr5�op�	num_no_op�
numupdates�progressr{r(r��for��cost�progrUr~�f0�origf0r��getfiledata�finalr�r�r��moves�mergeactionsr6r�r�r��fcl�fco�actx�fca�
unresolved�	msupdated�msmerged�	msremoved�extraactionsrrr�applyupdates�sz
�������$�
�	����������






����	
�����r�cCs�|j�dd�}|j�dd�}t�d�}|dur|j�dd�}zddlm}|�d�|j�dd�d	k}Wnt	y?d
}Ynw|r]|s_||j
kra||krctj�
d�re|j�td��dSdSdSdSdSdS)
Ns	fsmonitorswarn_when_unusedswarn_update_file_countr0swarn_update_file_count_rustr)�
extensionssmodesoffF)slinuxsdarwins�(warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor")
)rrd�	configintr�
importrustr<r��findr �KeyError�nullidr�sysplatformr�ror)r#�num_gets�p1node�fsmonitorwarning�fsmonitorthreshold�dirstate_rustmodr��fsmonitorenabledrrr�_advertisefsmonitor�sB�
�
���

����r�rsnoneslinears
noconflictc:
sJddlm}|dusJ�|s+|s+|
durt}
tttf}
|
|
vr+d}||
|
f;}t|��|dur8|��r8t��}n��	�}|���|durH�d}|�
�}|d}�|}|dur^�|g}n-�j�dd�dgkr��j
�|��|���}�fd	d
�t|�p�jgD�}n|j||d�g}|��|��t|�t|�f\}}}}|o�|}|s�t|�dkr�t�td���|��}|��r�td
�}td�}tj||d��|�r)td�}||gkr�t�|��||gkr�|s�|��|��kr�td�}td�}tj||d��|�s|���s|���rtd�}td�}tj||d��|���s(t|j�D]
}|�|�� ��qnb|�s�||k�rQ�j!dd|dd��j!d|ddd�t"dddd�Wd�S|
tk�r�||g|gfv�r�|j#dd�}|�r�t$�%�|��g�}�|��|v�r{ntd�}td�}tj&||d��	|�r�|g}n|�s�|g}�j�'dd�} |�r�d} n|d�s�d} |�s�|j#dd��s�d} t(�||||||| ||d�
}!|
tk�r�|!�)��r�td �}td�}tj||d��|!�*d!�}"|"�r^d!}#|"\}$}%}t+�,|�}&|#|&d"<|$t-j.k�r,�j�/td#�|&d��r|!�0|#t-j1dd$�nK|#|v�r"|!�0|#t-j2dd%�n<|!�0|#t-j3dd%�n2|$t-j4k�r^|%\}'}(})}*}+||(�5�},�j�/td&�|&d�dk�rY|!�0|#t-j6|,dfd'�n|!�7|#�t�8�j9��s�|�s||�ss|j#ddd(��s|t:�|�;�d�nt:�|�;�|!�tt<�=|!j>��D]\}#}-�j�?td)�|#�t|-�D]}.�j�?d*|.��q��q�tt<�=|!j@��D]\}#}-�j�?td+�|#�t|-�D]}.�j�?d*|.��qƐq�|�s�|�j|df\}}}}|du�p�|�A�}/|	�o�|/�o�|��}	|	�r�j!dd||d��jB�Cd,|�D��tE�|!�t-j6f�|���|	�o|}0tF�|!||||0|d-�\}1}2}3|	�r|3�rht<�=|3�D]0\}4}5|5D]}6|!j0|6d|4g|6dd��R��q=|4t-j6k�rf|0�rf|5D]	}6d|2|6d<�q\�q7t|2�|0�ru|!�t-j6f�ndk�s{J��jG�H��}|2�r�i}7tI�J�jB�}8|8du�r�d}2n7|8d}9t<�=|2�D]\}#}$|$du�r�|$d.d|9k�r�|$d|$ddf|7|#<�q�t<�=|7�D]	\}#}$|$|2|#<�q���K||�t-�L�|!jM||2�t�N�jB�Od,��|�s�jG�P|���|�s�|�Q��Wd�n	1�swYWd�n	1�swY|	�r#�j!d|||1jd�|1S)/a�	
    Perform a merge between the working directory and the given node

    node = the node to update to
    branchmerge = whether to merge between branches
    force = whether to force branch merging or file overwriting
    matcher = a matcher to filter file lists (dirstate not updated)
    mergeancestor = whether it is merging with an ancestor. If true,
      we should accept the incoming changes for any prompts that occur.
      If false, merging with an ancestor (fast-forward) is only allowed
      between different named branches. This flag is used by rebase extension
      as a temporary fix and should be avoided in general.
    labels = labels to use for local, other, and base
    mergeforce = whether the merge was run with 'merge --force' (deprecated): if
      this is True, then 'force' should be True as well.

    The table below shows all the behaviors of the update command given the
    -c/--check and -C/--clean or no options, whether the working directory is
    dirty, whether a revision is specified, and the relationship of the parent
    rev to the target rev (linear or not). Match from top first. The -n
    option doesn't exist on the command line, but represents the
    experimental.updatecheck=noconflict option.

    This logic is tested by test-update-branches.t.

    -c  -C  -n  -m  dirty  rev  linear  |  result
     y   y   *   *    *     *     *     |    (1)
     y   *   y   *    *     *     *     |    (1)
     y   *   *   y    *     *     *     |    (1)
     *   y   y   *    *     *     *     |    (1)
     *   y   *   y    *     *     *     |    (1)
     *   *   y   y    *     *     *     |    (1)
     *   *   *   *    *     n     n     |     x
     *   *   *   *    n     *     *     |    ok
     n   n   n   n    y     *     y     |   merge
     n   n   n   n    y     y     n     |    (2)
     n   n   n   y    y     *     *     |   merge
     n   n   y   n    y     *     *     |  merge if no conflict
     n   y   n   n    y     *     *     |  discard
     y   n   n   n    y     *     *     |    (3)

    x = can't happen
    * = don't-care
    1 = incompatible options (checked in commands.py)
    2 = abort: uncommitted changes (commit or update --clean to discard changes)
    3 = abort: uncommitted changes (checked in commands.py)

    The merge is performed inside ``wc``, a workingctx-like objects. It defaults
    to repo[None] if None is passed.

    Return the same tuple as applyupdates().
    rr5Nz&Invalid updatecheck %r (can accept %r)rrTspreferancestor�*csg|]}�|�qSrrr7r^rrrusz_update.<locals>.<listcomp>)rosoutstanding uncommitted mergesoutstanding merge conflictssuse 'hg resolve' to resolver�s7merging with a working directory ancestor has no effectsnothing to merges#use 'hg update' or check 'hg heads'suncommitted changessuse 'hg status' to list changess	preupdateTr�)�throw�parent1�parent2supdate)r�r�r)�missings+commit or update --clean to discard changessfollowcopiesF)rrtsconflicting changesr��fsjlocal%(l)s changed %(f)s which other%(o)s deleted
use (c)hanged version or (d)elete?$$ &Changed $$ &Deletes
prompt deletesprompt keepsrother%(o)s changed %(f)s which local%(l)s deleted
use (c)hanged version or leave (d)eleted?$$ &Changed $$ &Deletedsprompt recreating)r��branchs<note: possible conflict - %s was renamed multiple times to:
s %s
s9note: possible conflict - %s was deleted and renamed to:
supdatestate)r��)Rr<r6�UPDATECHECK_LINEAR�UPDATECHECK_NONE�UPDATECHECK_NO_CONFLICT�
ValueErrorr+r�nullcontextmanager�wlockr�r�
configlist�	changelog�commonancestorsheadsrrnr�r3r�r�rrprrrxr�r�rLr�rr��
bailifchanged�hookrtr�r�
foreground�UpdateAbortrdrFr�r�r�
partextrasrer��promptchoicerkr�r�r�rgr�rlr��fscasesensitiverzr�r�rr�r�ror�r��vfsra�hexr�r�r0�parentchanger�
get_fs_now�
setparents�
recordupdatesr��unlinkr!�	setbranch�prunetemporaryincludes):r#rr�rrr3�
mergeancestorr�rrt�updatedirstate�updatecheck�wcr6�okayr(�maybe_wlock�plr�r�pas�cahs�fp1�fp2�xp1�xp2r�r�r��m_ar�r�r�rrs�valsr5r�r{�promptsr�r6r�r�r�r�r��nfr�re�statsr�r��k�actsr��ambiguous_mtime�now�now_secrr^r�_updates�C

 $




�
�3�
�




���	�
�����	��
������������
$�
�2
�
�
�����D
�r�c	Cst|��|��|d|||d�S)z�Merge another topological branch into the working copy.

    force = whether the merge was run with 'merge --force' (deprecated)
    T)r�r�rrrtr��r�r#r)rpr�rrr�rrr�merge�s�r�c	Cs"t|��|��ddgd�||d�S)a�Do a regular update to the given commit, aborting if there are conflicts.

    The 'updatecheck' argument can be used to control what to do in case of
    conflicts.

    Note: This is a new, higher-level update() than the one that used to exist
    in this module. That function is now called _update(). You can hopefully
    replace your callers to use this new update(), or clean_update(), merge(),
    revert_to(), or graft().
    F)sworking copysdestinationsworking copy parent)r�rrr�r�r�r�)rpr�r�rrrrW�s�rWcCst|��|��dd|d�S)z�Do a clean update to the given commit.

    This involves updating to the commit and discarding any changes in the
    working copy.
    FT)r�rrr�r�)rpr�rrr�clean_update�sr�c	Cst|��|��ddd||d�S)z�Revert the working copy to the given commit.

    The working copy will keep its current parent(s) but its content will
    be the same as in the given commit.
    FT)r�rrr�rr�r�)rprr�rrr�	revert_to�s�r�c
CsP|p|d}|��}|p|��}|j�|��|���p"|��|��k}t||��dd|��|||d�}	|r=|	jr=|��}
n|j}
|��}|r[t	|�dkr[||vr[|�
|�|d��}
|
|��krd|j}
|��ry|�|��|
�t
�|||�|	S|j��� |�|��|
�|j�|���t
�|||�Wd�|	S1s�wY|	S)aIDo a graft-like merge.

    This is a merge where the merge ancestor is chosen such that one
    or more changesets are grafted onto the current changeset. In
    addition to the merge, this fixes up the dirstate to include only
    a single parent (if keepparent is False) and tries to duplicate any
    renames/copies appropriately.

    ctx - changeset to rebase
    base - merge base, or ctx.p1() if not specified
    labels - merge labels eg ['local', 'graft']
    keepparent - keep second parent if any
    keepconflictparent - if unresolved, keep parent used for the merge

    NT)r�r�r�r�r)r�r��
isancestorrrr�rxr�r�r�r�r+r�r	�graftcopiesr0r�ra�currenttransaction)r#rp�baser��
keepparent�keepconflictparentr3�pctxr�r��potherr�rrr�graft�sJ ��


�
��rcCsF|dur|��durd}t�|��|��}t|��|dd|��dd�S)Ns/must specify parent of merge commit to back outTF)r�rrr3r�)rr�ProgrammingErrorr�r�r#r)rp�parentr�r(rrr�back_outA	s
�rc	s���fdd�}	|j}
g}z�|rg}|j|_�j|||d�}
|r�t|
j�}t|
j�}|r8|r8td�}|||f;}n>|rCtd�}||;}n3|rNtd�}||;}n(|rvd}|D]}||�rd�j�|�sd|d7}qT|rptd	�}||;}n|W|
|_S|d
7}�j	j
|dd�dkr�t�td���|r�t
|
j|
j�D]}|s��j	�td
�|�|	�jj|�|�|�q�|r�t
|dd�D]$}||�r܈j�|�s�|s׈j	�td�|�|	�jj|�|�|�q�|W|
|_S|
|_w)aPurge the working directory of untracked files.

    ``matcher`` is a matcher configured to scan the working directory -
    potentially a subset.

    ``unknown`` controls whether unknown files should be purged.

    ``ignored`` controls whether ignored files should be purged.

    ``removeemptydirs`` controls whether empty directories should be removed.

    ``removefiles`` controls whether files are removed.

    ``abortonerror`` causes an exception to be raised if an error occurs
    deleting a file or directory.

    ``noop`` controls whether to actually remove files. If not defined, actions
    will be taken.

    ``confirm`` ask confirmation before actually removing anything.

    Returns an iterable of relative paths in the working directory that were
    or would be removed.
    csRz||�WdSty(td�|}�rt�|���j�td�|�YdSw)Ns%s cannot be removedswarning: %s
)rHrrr�rro)�removefnrzr���abortonerrorr#rrr�u	s
�zpurge.<locals>.remove)r
�ignored�unknowns3permanently delete %d unknown and %d ignored files?s$permanently delete %d unknown files?s$permanently delete %d ignored files?rrs1permanently delete at least %d empty directories?s (yN)$$ &Yes $$ &No)�defaultsremoval cancelledsremoving file %s
T)�reversesremoving directory %s
)�traversedirr�r�r�r
rrr,�listdirrr�r�
CanceledErrorrnrr��rmdir)r#rrr
�removeemptydirs�removefilesr	�noop�confirmr��oldtraversedirr��directoriesr��
nb_ignored�
nb_unknownr(�	dir_countr5rrr�purgeQ	sh$



��
�
�rr9r�r*)NFNNFTNN)NFNr�)NNFFN)TFTTFFF)F�
__future__rr�rI�struct�i18nrrr�
thirdpartyr�utilsr�
dirstateutilsrr<r	r
rrr
rrrerrrrrrrr�pack�_pack�unpack�_unpackr)r7�objectr8r�r�r�r�r�r�r�r2r4rFrLrWrnrrr�rtr�r��UPDATECHECK_ABORTr�r�r�r�r�rWr�r�rrrrrrr�<module>s�@
8!D
#0
�
�I	'V

�
5
�
#


	
�
L�
@ Telegram