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__/mergestate.cpython-310.pyc
o

�]Lb}}�@sddlmZddlZddlZddlZddlZddlZddlmZddl	m
Z
mZmZddl
mZmZmZmZddlmZejZejZdd	�Zd
d�ZdZd
ZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-Gd d!�d!e.�Z/e/dd"e,d#�Z0e/dd"e,d#�Z1e/d$d"e+d#�Z2e/d%d"e-d#�Z3e/d&�Z4e/d'�Z5e/d(d"e+d#�Z6e/d)d"e+d#�Z7e/d*�Z8e/d+�Z9e/d�Z:e/d,�Z;e/d-�Z<e/d.d"d/�Z=e/d0d"d/�Z>e/d1d"d/�Z?e/d2d"e-d#�Z@e/d3d"e+d#�ZAe:e<e9e8fZBGd4d5�d5e.�ZCGd6d7�d7eC�ZDGd8d9�d9eC�ZEd:d;�ZFdS)<�)�absolute_importN�)�_)�bin�hex�nullrev)�error�	filemerge�pycompat�util)�hashutilcCs,|�d�}|dd�|dd�}d�|�S)N�������)�split�join)�data�bits�r�6/usr/lib/python3/dist-packages/mercurial/mergestate.py�
_droponodes

rcCs$||��jjkrt�||�S||S�N)�repo�
nodeconstants�nullhexr	�
absentfilectx)�hexnode�ctx�frrr�_filectxorabsent"sr�L�O�l�f�F�C�P�u�rspuspr�o�t�R�d�m�Dsaddedsremovedsmodifiedc@sReZdZdZe��Ze��Zddd�Zdd�Z	dd	�Z
d
d�Zdd
�Zdd�Z
dS)�MergeActiona#represent an "action" merge need to take for a given file

    Attributes:

    _short: internal representation used to identify each action

    no_op:  True if the action does affect the file content or tracking status

    narrow_safe:
        True if the action can be safely used for a file outside of the narrow
        set

    changes:
        The types of changes that this actions involves. This is a work in
        progress and not all actions have one yet. In addition, some requires
        user changes and cannot be fully decided. The value currently available
        are:

        - ADDED: the files is new in both parents
        - REMOVED: the files existed in one parent and is getting removed
        - MODIFIED: the files existed in at least one parent and is getting changed
    FNcCs:||_|j�|�||_|jr|j�|�||_||_dSr)�_short�ALL_ACTIONS�add�no_op�
NO_OP_ACTIONS�narrow_safe�changes)�self�shortr3r5r6rrr�__init__�s
zMergeAction.__init__cCs
t|j�Sr)�hashr0�r7rrr�__hash__��
zMergeAction.__hash__cCsd|j�d�S)NzMergeAction<%s>�ascii)r0�decoder;rrr�__repr__�szMergeAction.__repr__cC�|jSr�r0r;rrr�	__bytes__��zMergeAction.__bytes__cCs&|durdSt|t�s
J�|j|jkS�NF)�
isinstancer/r0�r7�otherrrr�__eq__�szMergeAction.__eq__cCs|j|jkSrrBrGrrr�__lt__�szMergeAction.__lt__)FFN)�__name__�
__module__�__qualname__�__doc__�weakref�WeakSetr1r4r9r<r@rCrIrJrrrrr/js
	r/T)r5r6�a�g�p�prsam�csdcscdsdgsdm�k)r3skaskn�escmc@seZdZdZdd�Zdd�Zd9dd�Zejd	d
��Z	ejdd��Z
ejd
d��Zejdd��Zdd�Z
dd�Zedd��Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Z d7d8�Z!dS):�_mergestate_basea�track 3-way merge state of individual files

    The merge state is stored on disk when needed. Two files are used: one with
    an old format (version 1), and one with a new format (version 2). Version 2
    stores a superset of the data in version 1, including new kinds of records
    in the future. For more about the new format, see the documentation for
    `_readrecordsv2`.

    Each record can contain arbitrary content, and has an associated type. This
    `type` should be a letter. If `type` is uppercase, the record is mandatory:
    versions of Mercurial that don't support it should abort. If `type` is
    lowercase, the record can be safely ignored.

    Currently known records:

    L: the node of the "local" part of the merge (hexified version)
    O: the node of the "other" part of the merge (hexified version)
    F: a file to be merged entry
    C: a change/delete or delete/change conflict
    P: a path conflict (file vs directory)
    f: a (filename, dictionary) tuple of optional values for a given file
    l: the labels for the parts of the merge.

    Merge record states (stored in self._state, indexed by filename):
    u: unresolved conflict
    r: resolved conflict
    pu: unresolved path conflict (file conflicts with directory)
    pr: resolved path conflict
    o: file was merged in favor of other parent of merge (DEPRECATED)

    The resolve command transitions between 'u' and 'r' for conflicts and
    'pu' and 'pr' for path conflicts.
    cCs:||_i|_t�t�|_d|_d|_d|_i|_	d|_
dS)z^Initialize the merge state.

        Do not use this directly! Instead call read() or clean().NF)�_repo�_state�collections�defaultdict�dict�_stateextras�_local�_other�_labels�_results�_dirty�r7rrrrr9�s
z_mergestate_base.__init__cCsdSrrr;rrr�reset�sz_mergestate_base.resetNcCs||_||_||_dSr)r_r`ra)r7�noderH�labelsrrr�starts
z_mergestate_base.startcC�|jdurd}t�|��|jS)Ns(local accessed but self._local isn't set)r_r�ProgrammingError�r7�msgrrr�local�

z_mergestate_base.localcC�|j|jSr)rYrmr;rrr�localctx�z_mergestate_base.localctxcCri)Ns(other accessed but self._other isn't set)r`rrjrkrrrrHrnz_mergestate_base.othercCror)rYrHr;rrr�otherctxrqz_mergestate_base.otherctxcCst|j�p	t|j�S)z�Whether mergestate is active.

        Returns True if there appears to be mergestate. This is a rough proxy
        for "is a merge in progress."
        )�boolr_rZr;rrr�activesz_mergestate_base.activecCsdS)z*Write current state on disk (if necessary)Nrr;rrr�commit#sz_mergestate_base.commitcCstt�|����S)zUhash the path of a local file context for storage in the .hg/merge
        directory.)rr�sha1�digest)�pathrrr�getlocalkey&sz_mergestate_base.getlocalkeycC�t��r��NotImplementedError�r7�fctx�localkeyrrr�_make_backup-rDz_mergestate_base._make_backupcCrzrr{�r7r~r�flagsrrr�_restore_backup0rDz _mergestate_base._restore_backupc	Cs�|��r
|jjj}n
t�|���}|�||�t||��|��t	|�
��|��t	|�
��|��g|j|<t	|�
��|j|d<d|_dS)a/add a new (potentially?) conflicting file the merge state
        fcl: file context for local,
        fco: file context for remote,
        fca: file context for ancestors,
        fd:  file path of the resulting merge.

        note: also write the local version to the `.hg/merge` directory.
        �ancestorlinknodeTN)�isabsentrYrr�
mergestateryrxr��MERGE_RECORD_UNRESOLVEDr�filenoder�rZrfr^rc)r7�fcl�fco�fca�fdrrrrr23s	


�

z_mergestate_base.addcCst||g|j|<d|_dS)z�add a new conflicting path to the merge state
        path:    the path that conflicts
        frename: the filename the conflicting file was renamed to
        forigin: origin of the file ('l' or 'r' for local/remote)
        TN)�MERGE_RECORD_UNRESOLVED_PATHrZrc)r7rx�frename�foriginrrr�addpathconflictNs
z _mergestate_base.addpathconflictcCs|j|�|�d|_dS)zHstores information which is required at commit
        into _stateextrasTN)r^�updaterc)r7rxrrrr�
addcommitinfoWs
z_mergestate_base.addcommitinfocCs
||jvSr�rZ�r7�dfilerrr�__contains__]r=z_mergestate_base.__contains__cCs|j|dS)Nrr�r�rrr�__getitem__`�z_mergestate_base.__getitem__cCstt|j��Sr)�iter�sortedrZr;rrr�__iter__cr�z_mergestate_base.__iter__cCs
|j��Sr)rZ�keysr;rrr�filesfr=z_mergestate_base.filescCs||j|d<d|_dS)NrT)rZrc)r7r��staterrr�markis
z_mergestate_base.markccs2�t�|j�D]\}}|dttfvr|VqdS)z%Obtain the paths of unresolved files.rN)r
�	iteritemsrZr�r�)r7r�entryrrr�
unresolvedms����z_mergestate_base.unresolvedcCrA)z8return all extras information stored with the mergestate�r^r;rrr�	allextraswsz_mergestate_base.allextrascCs
|j|S)z?return extras stored with the mergestate for the given filenamer�)r7�filenamerrr�extras{s
z_mergestate_base.extrasc
Cs�||ttfvr
dS|j|}|\}}}}}}	}
}|j|j}|�|�}
|
�d�}|r1|j|}nd}t|||�}t|
||	�}|jj|||d�}|�	�}|�	�}d|||vr|d|||vr||�
�tkrv||krv|jj�
td�|�n||kr||}||jjjkr�|�||||�n||jdd	�|�|�s�|j|=d
|j|<d|_dStj|j||j|||||jd�\}}|s�|�|t�d}|r�|��r�t}nt}n|��r�t}n|��r�||jvr�t}nt }||f|j|<|S)zHrun merge process for dfile

        Returns the exit code of the merge.rr�N)�fileid�	changectx�xr"sQwarning: cannot merge flags for %s without common ancestor - keeping local flags
T)�
ignoremissing)NN)rg)!�MERGE_RECORD_RESOLVED�LEGACY_RECORD_DRIVER_RESOLVEDrZrYr`r��getr�filectxr��revr�ui�warnrrrr��remove�cmprbrcr	r_rar�r��
ACTION_FORGET�
ACTION_REMOVE�
ACTION_GETrp�ACTION_ADD_MODIFIED�
ACTION_ADD)r7r��wctx�
stateentryr�r�lfile�afile�anode�ofile�onoder��octxr��
anccommitnode�actx�fcdr�r��flo�fla�	merge_ret�deleted�actionrrr�resolves|�


 ���


�
z_mergestate_base.resolvecCs^d\}}}t�|j�D]\}}|dur|d7}q|dkr)|tkr%|d7}q|d7}q|||fS)zKreturn counts for updated, merged and removed files in this
        session)rrrNrr)r
�
itervaluesrbr�)r7�updated�merged�removed�rr�rrr�counts�s


�
z_mergestate_base.countscCstt|����S)z0get unresolved count for this merge (persistent))�len�listr�r;rrr�unresolvedcount�sz _mergestate_base.unresolvedcountc
CsRtgtgtgtgtgi}t�|j�D]\}\}}|dur&||�|ddf�q|S)z2return lists of actions to perform on the dirstateNsmerge result)	r�r�r�r�r�r
r�rb�append)r7�actionsrr�r�rrrr��s��z_mergestate_base.actionsr)"rKrLrMrNr9rerhr�
propertycachermrprHrrrtru�staticmethodryr�r�r2r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrrrX�sD"





	
UrXc@s�eZdZdZdZedd��Zedd��Zdd�Zd	d
�Z	dd�Z
d
d�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!S)"r�smerge/statesmerge/state2cC�t|�}|��|S)zPInitialize a brand new merge state, removing any existing state on
        disk.)r�re�r�msrrr�clean�szmergestate.cleancCr�)z1Initialize the merge state, reading it from disk.)r��_readr�rrr�readszmergestate.readcCsVt�}|��}|D]�\}}|tkrt|�|_q	|tkr!t|�|_q	|tkr&q	|tt	t
ttfvrP|�
d�}|dtkrDd|j|dd<q	|dd�|j|d<q	|tkr�|�
dd�\}}|�
d�}i}	d}
|
t|�kr||
d|	||
<|
d7}
|
t|�ksk|	|j|<q	|tkr�|�
dd�}dd	�|D�|_q	|��s�|�|�q	|r�t�|��dS)
z�Analyse each record content to restore a serialized state from disk

        This function process "record" entry produced by the de-serialization
        of on disk file.
        r
rsotherrsfilenode-sourceN�cSsg|]
}t|�dkr|�qS)r)r�)�.0�lrrr�
<listcomp>3sz$mergestate._read.<locals>.<listcomp>)�set�_readrecords�RECORD_LOCALrr_�RECORD_OTHERr`�LEGACY_MERGE_DRIVER_STATE�
RECORD_MERGED�RECORD_CHANGEDELETE_CONFLICT�RECORD_PATH_CONFLICT�LEGACY_MERGE_DRIVER_MERGE�LEGACY_RECORD_RESOLVED_OTHERr�MERGE_RECORD_MERGED_OTHERr^rZ�RECORD_FILE_VALUESr��
RECORD_LABELSra�islowerr2r�UnsupportedMergeRecords)r7�unsupported�records�rtype�recordrr��	rawextras�
extrapartsr��irgrrrr�	sN�

�
�
�zmergestate._readcCs�|��}|��}|�||�r|S|jd��d}|�t|��f�t|�D]"\}}|dt	krH|d�
d�}|�dd�|dd�|�f||<q&|S)a�Read merge state from disk and return a list of record (TYPE, data)

        We read data from both v1 and v2 files and decide which one to use.

        V1 has been used by version prior to 2.9.1 and contains less data than
        v2. We read both versions and check if no data in v2 contradicts
        v1. If there is not contradiction we can safely assume that both v1
        and v2 were written at the same time and use the extract data in v2. If
        there is contradiction we ignore v2 content as we assume an old version
        of Mercurial has overwritten the mergestate file and left an old v2
        file around.

        returns list of record [(TYPE, data), ...]Nrrrr
r�)
�_readrecordsv1�_readrecordsv2�
_v1v2matchrY�parentsr�r�r�	enumerater�r�insertr)r7�	v1records�	v2records�mctx�idxr�rrrrr�:s�zmergestate._readrecordscCsft�}|D]}|dtkr|�|�q|dtkr$|�tt|d�f�q|D]	}||vr0dSq'dS)NrrFT)r�r�r2r�r)r7r�r��oldv2�recrrrr�\s��zmergestate._v1v2matchc
Cs�g}z2|j�|j�}t|�D]\}}|dkr"|�t|dd�f�q|�t|dd�f�q|��W|StyN}z|j	t	j
krC�WYd}~|Sd}~ww)z�read on disk merge state for version 1 file

        returns list of record [(TYPE, data), ...]

        Note: the "F" data from this file are one entry short
              (no "other file node" entry)
        rNr)rY�vfs�statepathv1r�r�r�r��close�IOError�errno�ENOENT)r7r�rr�r��errrrrr�js 
�
���zmergestate._readrecordsv1c

Cs�g}za|j�|j�}|��}d}t|�}||kr]|||d�}|d7}td|||d��d}|d7}||||�}||7}|tkrR|dd�|dd�}}|�||f�||ks|��W|St	y}}	z|	j
t
jkrr�WYd}	~	|Sd}	~	ww)aread on disk merge state for version 2 file

        This format is a list of arbitrary records of the form:

          [type][length][content]

        `type` is a single character, `length` is a 4 byte integer, and
        `content` is an arbitrary byte sequence of length `length`.

        Mercurial versions prior to 3.7 have a bug where if there are
        unsupported mandatory merge records, attempting to clear out the merge
        state with hg update --clean or similar aborts. The 't' record type
        works around that by writing out what those versions treat as an
        advisory record, but later versions interpret as special: the first
        character is the 'real' record type and everything onwards is the data.

        Returns list of records [(TYPE, data), ...].rrs>I�N)rYr�statepathv2r�r��_unpack�RECORD_OVERRIDEr�rrrr	)
r7r�rr�off�endr��lengthr�r
rrrr��s4�

�
���zmergestate._readrecordsv2cCs&|jr|��}|�|�d|_dSdSrE)rc�_makerecords�
_writerecords�r7r�rrrru�s


�zmergestate.commitcCs:g}|�tt|j�f�|�tt|j�f�t�|j�D]G\}}|dt	t
fvr6|�td�|g|�f�q|d|j
jjksH|d|j
jjkrV|�td�|g|�f�q|�td�|g|�f�qtt�|j��D]\}}d�dd�t�|�D��}|�td||ff�ql|jdur�d�|j�}|�t|f�|S)Nrr
r�css �|]\}}d||fVqdS)�%s%sNr)r��k�vrrr�	<genexpr>�s�
�z*mergestate._makerecords.<locals>.<genexpr>r)r�r�rr_r�r`r
r�rZr��MERGE_RECORD_RESOLVED_PATHr�rrYrrr�r�r�r^r�rar�)r7r�r�rr�r�rgrrrr�s8���
��
zmergestate._makerecordscCs|�|�|�|�dS)z,Write current state on disk (both v1 and v2)N)�_writerecordsv1�_writerecordsv2rrrrr�s
zmergestate._writerecordscCsx|j�|jd�}t|�}t|�}|dtksJ�|�t|j�d�|D]\}}|t	kr5|�dt
|��q$|��dS)z/Write current state on disk in a version 1 file�wbr�
s%s
N)rYrrr��nextr��writerr_r�rr)r7r�r�irecords�lrecordsr�rrrrr�s�zmergestate._writerecordsv1cCs�tttf}|j�|jd�}|D]+\}}t|�dksJ�||vr(td||f}}dt|�}|�t	||t|�|��q|�
�dS)zqWrite current state on disk in a version 2 file

        See the docstring for _readrecordsv2 for why we use 't'.rrs%s%ss>sI%isN)r�r�r�rYrrr�rr �_packr)r7r��	allowlistr�keyr�formatrrrr�s
zmergestate._writerecordsv2cCs|jj�d||���dS�Nsmerge/)rYrr rr}rrrr��szmergestate._make_backupcCsF|j�d|��}|�|��|�Wd�dS1swYdSr')rYrr r�)r7r~rr�rrrrr��s"�zmergestate._restore_backupcCst�|jj�d�d�dS)NsmergeT)�shutil�rmtreerYrrr;rrrreszmergestate.resetN)rKrLrMrrr�r�r�r�r�r�r�r�rurrrrr�r�rerrrrr��s(

1"(-r�cs,eZdZ�fdd�Zdd�Zdd�Z�ZS)�
memmergestatecstt|��|�i|_dSr)�superr*r9�_backupsrd��	__class__rrr9s
zmemmergestate.__init__cCs|��|j|<dSr)rr,r}rrrr�szmemmergestate._make_backupcCs|�|j||�dSr)r r,r�rrrr�szmemmergestate._restore_backup)rKrLrMr9r�r��
__classcell__rrr-rr*sr*cCs�|�tg�D]\}}}|r|jj|ddd�q|jj|ddd�q|�tg�D]\}}}|jj|ddd�q'|�tg�D]0\}}}|\}}|jj|ddd�|j�||�||krc|jj|ddd�q<|jj|ddd�q<|�tg�D]\}}}|jj|ddd�qs|�tg�D]\}}}|r�|jj|dddd�q�|jj|ddd�q�|�t	g�D]\}}}|jj|dddd�q�|�t
g�D]\}}}q�|�tg�D]\}}}q�|�tg�D]\}}}q�|�t
g�D]3\}}}|�r|j�|�}	|	jo�|	j}
|jj||
ddd�q�|�r||nd}|jj|dd|d�q�|�tg�D]a\}}}|\}}
}}}|�rc||k}
|jj||
ddd�||
k�ra|�rL|jj|ddd�||k�rZ|j�||��q|j�|
|��q|
|k�rr|jj|dddd�|�r~|jj|ddd��q|�tg�D]:\}}}|\}}|�r�|jj|ddd�|jj|ddd�|j�||��q�|jj|ddd�|jj|ddd��q�|�tg�D](\}}}|\}}|�r�|jj|ddd�|j�||��q�|jj|ddd��q�dS)z$record merge actions to the dirstateTF)�
p1_tracked�
wc_tracked)r0r1�possibly_dirty)r0r1�p2_infoN)r0r1�parentfiledata)r�r��dirstate�update_filer��ACTION_PATH_CONFLICT_RESOLVE�copyr�r��ACTION_EXEC�ACTION_KEEP�ACTION_KEEP_ABSENT�ACTION_KEEP_NEWr��	get_entry�any_tracked�added�ACTION_MERGE�ACTION_DIR_RENAME_MOVE_LOCAL�ACTION_LOCAL_DIR_RENAME_GET)rr��branchmerge�getfiledatar�argsrl�f0�origf0�	old_entryr0r4�f1�f2�fa�move�anc�flagrrr�
recordupdatess������
�
�
����rO)G�
__future__rr[rr(�structrO�i18nrrfrrr�rr	r
r�utilsr�packr#�unpackr
rrr�r�r�r�r�r�r�r�r�r�rr�rr�r�r�r��CHANGE_ADDED�CHANGE_REMOVED�CHANGE_MODIFIED�objectr/r�r�r�r��ACTION_PATH_CONFLICTr7r��ACTION_CREATED�ACTION_DELETED_CHANGED�ACTION_CHANGED_DELETEDr@rBrAr:r;r<r9�ACTION_CREATED_MERGE�CONVERT_MERGE_ACTIONSrXr�r*rOrrrr�<module>s�
7���/
@ Telegram