403Webshell
Server IP : 74.208.236.16  /  Your IP : 216.73.216.220
Web Server : Apache
System : Linux info 3.0 #1337 SMP Tue Jan 01 00:00:00 CEST 2000 all GNU/Linux
User : u102440577 ( 7172810)
PHP Version : 8.4.26
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /kunden/lib/python3/dist-packages/mercurial/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /kunden/lib/python3/dist-packages/mercurial/__pycache__/localrepo.cpython-313.pyc
�

6�h[I���SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK	r	SSK
Jr SSKJrJ
r
 SSKJr SSKJrJrJrJrJr SSKJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r(J)r*J+r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r8J9r9J:r:J;r;J<r<J=r=J>r?J@r@JArBJCrCJDrDJErEJFrGJHrH SS	KIJJrK SS
KLJMrM SSKNJOrO SSKPJQrQJRrRJSrSJTrT SS
KUJVrWJXrYJZr[ \(R�r\\ER�r]\ER�r^\R�"S5r`\a"5rb"SS\<R�5rd"SS\d5re"SS\d5rf"SS\f5rg"SS\f5rh"SS\d5riSrj"SS\ER�5rl"SS\ER�5rmS rnS!ro1S"krp\pR�S#15rr"S$S%\OR�5rt"S&S'\OR�\OR�5rw"S(S)\w\OR�5ry\a"5rzS*r{SHSIS+jjr|SHSJS,jjr}S-r~S.rS/r�S0r�S1r�S2r�S3r�S4r�"S5S6\OGR5r�"S7S8\OGR5r�S9r�\OGRS:4\OGRS;4/r�\�r�\GR(a\OGR\OGR/r�"S<S=\�5r�SKS>jr�SLSIS?jjr�SMS@jr�SHSAjr�SBr�SCr�SDr�SEr�SLSISFjjr�SGr�g)N�)�annotationsN)�futures)�Optional�Set�)�_)�bin�hex�nullrev�sha1nodeconstants�short)+�	bookmarks�	branchmap�bundle2�bundlecaches�changegroup�color�commit�context�dirstate�	discovery�encoding�error�exchange�
extensions�filelog�hook�lock�match�
mergestate�	mergeutil�
namespaces�
narrowspec�obsolete�pathutil�phases�policy�pushkey�pycompat�repoview�requirements�revlog�revset�
revsetlang�scmutil�sparse�store�subrepoutil�tags�transaction�txnutil�util�vfs�wireprototypes)�	rev_cache)�rcutil)�
repository)�hashutil�procutil�
stringutil�urlutil)�concurrency_checker�	constants�sidedatas+^((dirstate|narrowspec.dirstate).*|branch$)c�<^�\rSrSrSrSU4SjjrU4SjrSrU=r$)�_basefilecache�rzHAll filecache usage on repo are done for logic that should be unfilteredc�>�UcU$UR5nURUR$![a Of=f[TU]X25$�N)�
unfiltered�__dict__�sname�KeyError�super�__get__��self�repo�type�unfi�	__class__s    ��5/usr/lib/python3/dist-packages/mercurial/localrepo.pyrM�_basefilecache.__get__usR����<��K���� ��	��=�=����,�,���	��	���w��t�*�*s�1�
>�>c�@>�[TU]UR5U5$rG)rL�setrH)rOrP�valuerSs   �rTrW�_basefilecache.set�s����w�{�4�?�?�,�e�4�4��rG)	�__name__�
__module__�__qualname__�__firstlineno__�__doc__rMrW�__static_attributes__�
__classcell__�rSs@rTrDrDrs���R�	+�5�5rZrDc�2^�\rSrSrSrU4SjrSrSrU=r$)�
repofilecache�z3filecache for files in .hg but outside of .hg/storec�`>�[TU]"U6 UHn[RUS45 M g)N�plain�rL�__init__�_cachedfiles�add�rO�paths�pathrSs   �rTrj�repofilecache.__init__�s-���
���%� ��D����d�H�-�.�rZc�8�URRU5$rG)r7�join�rO�obj�fnames   rTrr�repofilecache.join�s���w�w�|�|�E�"�"rZr[�	r\r]r^r_r`rjrrrarbrcs@rTrere�s���=�/�
#�#rZrec�2^�\rSrSrSrU4SjrSrSrU=r$)�
storecache�z filecache for files in the storec�`>�[TU]"U6 UHn[RUS45 M g)NrZrirms   �rTrj�storecache.__init__�s,���
���%� ��D����d�C�[�)�rZc�$�URU5$rG)�sjoinrss   rTrr�storecache.join�s���y�y���rZr[rwrcs@rTryry�s���*�*�
 � rZryc�2^�\rSrSrSrU4SjrSrSrU=r$)�changelogcache�zfilecache for the changelogc�v>�[TU]5 [RS5 [RS5 g)N��
00changelog.irZ)�
00changelog.nrZri�rOrSs �rTrj�changelogcache.__init__�s,���
�������0�1����0�1rZc���URUS5/nURRRR	SS5(a!URURUS55 U$)Nr��persistent-nodemapFr��rrr1�opener�options�get�append�rOrtrns   rT�
tracked_paths�changelogcache.tracked_paths�sW�����3� 0�1�2���9�9���#�#�'�'�(=�u�E�E��L�L����3�(8�9�:��rZr[�	r\r]r^r_r`rjr�rarbrcs@rTr�r��s���%�2�
�rZr�c�2^�\rSrSrSrU4SjrSrSrU=r$)�manifestlogcache�zfilecache for the manifestlogc�v>�[TU]5 [RS5 [RS5 g)N)�00manifest.irZ)�00manifest.nrZrir�s �rTrj�manifestlogcache.__init__�s,���
�������/�0����/�0rZc���URUS5/nURRRR	SS5(a!URURUS55 U$)Nr�r�Fr�r�r�s   rTr��manifestlogcache.tracked_paths�sU�����3��0�1���9�9���#�#�'�'�(=�u�E�E��L�L����3��8�9��rZr[r�rcs@rTr�r��s���'�1�
�rZr�c�2^�\rSrSrSrU4SjrSrSrU=r$)�mixedrepostorecache�z2filecache for a mix files in .hg/store and outsidec�J>�[TU]"U6 [RU5 grG)rLrjrk�update)rO�pathsandlocationsrSs  �rTrj�mixedrepostorecache.__init__�s"���	���+�,����-�.rZc��Uup4US:XaURRU5$US:wa[R"SU-5eUR	U5$)NrhrZsunexpected location: %s)r7rrr�ProgrammingErrorr~)rOrt�fnameandlocationru�locations     rTrr�mixedrepostorecache.join�sW��*����x���7�7�<�<��&�&��3���,�,�.��9����9�9�U�#�#rZr[rwrcs@rTr�r��s���<�/�	$�	$rZr�c��UR5RRUS5nU(dgURS4$)zscheck if a repo has already cached "name" filecache-ed property

This returns (cachedobj-or-None, iscached) tuple.
N�NFT)rH�
_filecacher�rt)rP�name�
cacheentrys   rT�isfilecachedr��s8��
���"�-�-�1�1�$��=�J����>�>�4��rZc�0^�\rSrSrSrSU4SjjrSrU=r$)�unfilteredpropertycache��z0propertycache that apply to unfiltered repo onlyc�t>�UR5nX1La[TU]	U5$[X0R5$rG)rHrLrM�getattrr�rNs    �rTrM�unfilteredpropertycache.__get__�s2������ ���<��7�?�4�(�(��t�Y�Y�'�'rZr[rG)r\r]r^r_r`rMrarbrcs@rTr�r��s���:�(�(rZr�c��\rSrSrSrSrSrg)�filteredpropertycache��z1propertycache that must take filtering in accountc�D�[RXRU5 grG)�object�__setattr__r�)rOrtrXs   rT�
cachevalue� filteredpropertycache.cachevalue�s�����3�	�	�5�1rZr[N)r\r]r^r_r`r�rar[rZrTr�r��s
��;�2rZr�c�:�U[UR55;$)z?check if a repo has an unfilteredpropertycache value for <name>)�varsrH)rPr�s  rT�hasunfilteredcacher��s���4����)�*�*�*rZc�F^�[R"T5U4Sj5nU$)z@decorate method that always need to be run on unfiltered versionc�8>�T"UR5/UQ70UD6$rG)rH)rP�args�kwargs�origs   �rT�wrapper�!unfilteredmethod.<locals>.wrapper�s����D�O�O�%�7��7��7�7rZ)�	functools�wraps)r�r�s` rT�unfilteredmethodr��s'����_�_�T��8��8��NrZ>�known�lookup�pushkey�unbundle�	branchmap�	getbundleschangegroupsubsetc�8�\rSrSrSrSrSrSrSrSr	Sr
g	)
�localcommandexecutoric�,�XlSUlSUlgr�)�_peer�_sent�_closed)rO�peers  rTrj�localcommandexecutor.__init__s���
���
���rZc��U$rGr[�rOs rT�	__enter__�localcommandexecutor.__enter__����rZc�$�UR5 grG)�close)rO�exctype�excvalue�exctbs    rT�__exit__�localcommandexecutor.__exit__s���
�
�rZc��UR(a[R"S5eUR(a[R"S5e[	UR
[R"U55n[R"5nU"S0[R"U5D6nURU5 U$![a1 [R"U[R"5SS5 U$f=f)Ns1callcommand() cannot be used after sendcommands()s*callcommand() cannot be used after close()rr[)r�rr�r�r�r�r)�sysstrr�Future�	strkwargs�
set_result�	Exception�future_set_exception_info�sys�exc_info)rO�commandr��fn�f�results      rT�callcommand� localcommandexecutor.callcommands����:�:��(�(�D��
��<�<��(�(�=��
��T�Z�Z�����!9�
:���N�N���	!��3�(�,�,�T�2�3�F�
�L�L�� �����	F��.�.�q�#�,�,�.���2D�E���	F�s�B>�>7C9�8C9c��SUlg�NT)r�r�s rT�sendcommands�!localcommandexecutor.sendcommands+s	����
rZc��SUlgr�)r�r�s rTr��localcommandexecutor.close.s	����rZ)r�r�r�N)r\r]r^r_rjr�r�r�r�r�rar[rZrTr�r�s ���
���4�rZr�c�^�\rSrSrSrSU4SjjrSrSrSrSr	SSjr
S	rS
rSr
SSjrSS
jrSrSrSrSrSrSrSrSrSrU=r$)�	localpeeri2z8peer for a local repo; reflects only the most recent APIc�n>�[TU]URX4S9 Uc[R	5nU(aURS5UlOURS5UlUR(a*[R"U5nURSU-5 URU5Ulg)N�ro�remotehidden�
served.hidden�servedsexp-wanted-sidedata=)
rLrj�ui�
moderncaps�copy�filtered�_repo�_wanted_sidedatar�format_remote_wanted_sidedatarl�_restrictcapabilities�_caps)rOrP�capsror��	formattedrSs      �rTrj�localpeer.__init__5s����
������t��G��<��?�?�$�D�����'7�8�D�J����y�1�D�J�� � ��=�=�d�C�I��H�H�,�y�8�9��/�/��5��
rZc�6�URR5$rG)r�urlr�s rTr
�
localpeer.urlFs���z�z�~�~��rZc��UR$rG)rr�s rT�local�localpeer.localI����z�z�rZc��gr�r[r�s rT�canpush�localpeer.canpushL���rZc�8�URR5 grG)rr�r�s rTr��localpeer.closeOs���
�
���rZc��UR$rG)rr�s rT�capabilities�localpeer.capabilitiesVrrZc�6�URR5$rG)rrr�s rTr�localpeer.branchmap]s���z�z�#�#�%�%rZc��[erG)�NotImplementedError)rOros  rT�get_cached_bundle_inline�"localpeer.get_cached_bundle_inline`s��!�!rZc�B�[R"UR5$rG)r�get_manifestrr�s rT�clonebundles�localpeer.clonebundlesds���(�(����4�4rZc��SUU[R"U5[R"U5[R"U54-$)z+Used to test argument passing over the wire�%s %s %s %s %s�r)�bytestr�rO�one�two�three�four�fives      rT�
debugwireargs�localpeer.debugwireargsg�D�� ������U�#����T�"����T�"�$
�
�	
rZc�*�[R"URU4UUUUS.UD6Sn[R"U5n[R
"U5(a![R"URU5$[R"SUS5$)N)�heads�common�
bundlecaps�remote_sidedatar�01)
r�getbundlechunksrr6�chunkbuffer�bundle2requestedr�getunbundlerrr)	rO�sourcer4r5r6r7r��chunks�cbs	         rT�	getbundle�localpeer.getbundleqs����)�)��J�J��
���!�+�

��
��
���
�
�f�
%���$�$�Z�0�0��'�'�����4�4��+�+�E�2�t�<�<rZc�6�URR5$rG)rr4r�s rTr4�localpeer.heads�s���z�z���!�!rZc�8�URRU5$rG)r�known�rO�nodess  rTrE�localpeer.known�s���z�z����&�&rZc�8�URRU5$rG)r�listkeys)rO�	namespaces  rTrJ�localpeer.listkeys�s���z�z�"�"�9�-�-rZc�8�URRU5$rG)r�lookup�rO�keys  rTrN�localpeer.lookup�s���z�z� � ��%�%rZc�:�URRXX45$rG)rr()rOrKrP�old�news     rTr(�localpeer.pushkey�s���z�z�!�!�)�#�;�;rZc�@�[R"[S55e)Ns.cannot perform stream clone against local peer)r�Abortrr�s rT�
stream_out�localpeer.stream_out�s���k�k�!�M�N�O�OrZc��[R"URUS5n[R"URXSU5n[US5(aE[R"UR55n[R"URU5nU$![a�n[USS5nU(a�[R"URR5nUHn	URU	5 M [R"UR55n[R"URU5n
[R"URU
5 eSnAff=f![ R"a9n[ R$"['S5[(R*"U55eSnAff=f)zHapply a bundle on a repo

This function handles the repo locking itself.Nspush�	getchunks�_bundle2salvagedoutputr[spush failed:)r�
readbundler�unbundler�hasattrr6r:r[rr<r�r��bundle20�addpart�
processbundler�	PushRaced�
ResponseErrorrr>�forcebytestr)rO�bundler4r
�ret�stream�exc�output�bundler�out�bs           rTr^�localpeer.unbundle�sS��	�
�!�,�,�T�W�W�f�d�C���'�'��
�
�F�7�C�P���3��,�,�"�-�-�c�m�m�o�>�F�!�.�.�t�w�w��?�C��
���
�!��&>��C���%�.�.�t�z�z�}�}�=�G�%������,� &�!�-�-�g�.?�.?�.A�B�F��,�,�T�W�W�f�=�A��)�)�$�*�*�a�8���!
��"���	��%�%��/�"�J�$;�$;�C�$@��
��	�s1�BB � 
E.�*B?E)�)E.�.E1�1F>�4F9�9F>c��[U5$rG)r�r�s rT�commandexecutor�localpeer.commandexecutor�s
��#�D�)�)rZ)rr�NNF)�returnz
Set[bytes]�NNN)NNNN)r\r]r^r_r`rjr
rrr�rrr r$r0r@r4rErJrNr(rXr^rprarbrcs@rTr�r�2sz���B�
6�" �����&�"�5�
�����
=�8"�'�.�&�<�P�#�R*�*rZr�c�H^�\rSrSrSrS	U4SjjrSrSrSrSr	Sr
U=r$)
�locallegacypeeri�z_peer extension which implements legacy methods too; used for tests with
restricted capabilitiesc�,>�[TU]U[X#S9 g)N)r	ror�)rLrj�
legacycaps)rOrPror�rSs    �rTrj�locallegacypeer.__init__�s���
����z��	�	
rZc�8�URRU5$rG)r�between)rO�pairss  rTr{�locallegacypeer.between�s���z�z�!�!�%�(�(rZc�8�URRU5$rG)r�branchesrFs  rTr�locallegacypeer.branches�s���z�z�"�"�5�)�)rZc��[R"URXRR5S9n[R
"URUSU5$�N)�missingroots�ancestorsofr8)r�outgoingrr4r�makechangegroup)rOrGr=r�s    rTr�locallegacypeer.changegroup�sE���%�%��J�J�U�
�
�8H�8H�8J�
���*�*�4�:�:�x���O�OrZc��[R"URXS9n[R"URUSU5$r�)rr�rrr�)rO�basesr4r=r�s     rT�changegroupsubset�!locallegacypeer.changegroupsubset�s8���%�%��J�J�U�
���*�*�4�:�:�x���O�OrZr[r�)r\r]r^r_r`rjr{rrr�rarbrcs@rTrvrv�s)����
�)�*�P�P�PrZrvc�d�URS5RS5n[RU;a%[R
"UR
U55n[R"USS9nUR5(d,[R"[S5UR-5eU$)z�returns the vfs object pointing to root of shared source
repo for a shared repository

hgvfs is vfs pointing at .hg/ of current repo (shared one)
requirements is a set of requirements of current repo (shared one)
�
sharedpath�
T)�realpaths1.hg/sharedpath points to nonexistent directory %s)�read�rstrip�requirementsmod�RELATIVE_SHARED_REQUIREMENTr6�normpathrr�vfsmodr7�existsr�	RepoErrorr�base)�hgvfsr+�
sharedpath�	sharedvfss    rT�
_getsharedvfsr��s������M�*�1�1�%�8�J��2�2�l�B��]�]�5�:�:�j�#9�:�
��
�
�:��5�I�������o�o�
�B�C��n�n�
�
�	
��rZc���UR5nURUl[R"USSS9nURS5n[R"USS9nSnSnUR	5(d3UR5 [R"[S5U-5e[R"US5n
[ R"U
;=(d [ R$U
;nSnU(a1['Xj5n[R"URS	55nO%[R"URS	55n[S
5n[ R(U
;a�U(a�[ R([R"US5;a�UR+SS5n
UR-SS
5nUR+SS5nUS;aSSKJn UR3UUUU
UU
U5 GO1US:Xa[R"[S5US9e[R"[S5U-US9eU
[R"US5-n
O�U(a�[R"US5n[ R(U;a�UR-SS5nUR+SS5n
UR+SS5nUS;aSSKJn UR5UUUU
UU
U5 OEUS:Xa[R"[S5US9e[R"[S5U-US9e[7X4XjU5(a8[9X4Xj5 [:R<"U5 [:R>"U5 [:R:"U5VVs1sHunnUR@iM nnn[CU5n[EU
U5 [GX:5 [I5nU(a=URJnURS5nURM[NRP5 OURJnURS5nURS5n[SU
US5nURTUl*URn[WX:U5Ul,[ RZU
;d[ R\U
;a>URM[NR^5 URa[NRb5 [R"USS9nURTUl*[R"USS9nURTUl*/n0n[dHgunn U "5"UUU
UUUUUURXUUUUUS9n![gU![h5(d[Rj"S U-5eURmU!5 Mi [nRp"S!URJS"R[sU
554-5n"[iU"[uU505n#U#"UUUUUU
UUUUUUUS#9
$![a GN�[a=n	[R"[S5U[R"U	54-5eSn	A	ff=fs snnf)$a	Create a local repository object.

Given arguments needed to construct a local repository, this function
performs various early repository loading functionality (such as
reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that
the repository can be opened, derives a type suitable for representing
that repository, and returns an instance of it.

The returned object conforms to the ``repository.completelocalrepository``
interface.

The repository type is derived by calling a series of factory functions
for each aspect/interface of the final repository. These are defined by
``REPO_INTERFACES``.

Each factory function is called to produce a type implementing a specific
interface. The cumulative list of returned types will be combined into a
new type and that type will be instantiated to represent the local
repository.

The factory functions each receive various state that may be consulted
as part of deriving a type.

Extensions should wrap these factory functions to customize repository type
creation. Note that an extension's wrapped function may be called even if
that extension is not loaded for the repo being constructed. Extensions
should check if their ``__name__`` appears in the
``extensionmodulenames`` set passed to the factory function and no-op if
not.
T��
expandpathr��.hg��cacheauditedFNsinvalid path %s: %ssrepository %s not found�stores?see `hg help config.format.use-share-safe` for more informationsshares"safe-mismatch.source-not-safe.warnssafe-mismatch.source-not-safes-safe-mismatch.source-not-safe:verbose-upgrade)sdowngrade-allow�allowsdowngrade-abortr��upgrade�aborts4share source does not support share-safe requirement��hintsfshare-safe mismatch with source.
Unrecognized value '%s' of `share.safe-mismatch.source-not-safe` set.ssafe-mismatch.source-safessafe-mismatch.source-safe.warns)safe-mismatch.source-safe:verbose-upgrade)s
upgrade-allowr�s
upgrade-abortsWversion mismatch: source uses share-safe functionality while the current share does notsbshare-safe mismatch with source.
Unrecognized value '%s' of `share.safe-mismatch.source-safe` set.�cache�wcachec�,�[R"USS9$)NTr�)r�r7)r�s rT�<lambda>�%makelocalrepository.<locals>.<lambda>�s��V�Z�Z��4�8rZ)r�intentsr+�features�wdirvfsr�r1�storevfs�storeoptions�cachevfs�	wcachevfs�extensionmodulenames�
extrastate�baseclassessunable to construct type for %ssderivedrepo:%s<%s>�,)
�baseuir�origrootr�r�r+�supportedrequirementsr�r1r�r�r�r�);rr�r7rr�isdir�stat�FileNotFoundError�
ValueErrorrrWrr>rer�r/�readrequiresr��SHARED_REQUIREMENTr�r��SHARESAFE_REQUIREMENT�
configbool�config�r��downgrade_share_to_non_safe�upgrade_share_to_safe�loadhgrc�
afterhgrcloadr�loadall�
populateuir\�gathersupportedrequirements�ensurerequirementsrecognized�ensurerequirementscompatiblerWr�rlr;�REPO_FEATURE_SHARED_STORAGE�	makestore�
createmode�resolvestorevfsoptionsr��REVLOGV2_REQUIREMENT�CHANGELOGV2_REQUIREMENT�REPO_FEATURE_SIDE_DATA�discard�REPO_FEATURE_STREAM_CLONE�REPO_INTERFACES�
isinstancerQr�r�r)r��sorted�tuple)$r�ror�rr��hgpathr��sharedr��er+r�r��
mismatch_warn�mismatch_config�mismatch_verbose_upgrader��sourcerequires�n�mr�r�r��
storebasepath�	cachepath�
wcachepathr1r�r�r�r��ifacer��typr��clss$                                    rT�makelocalrepositoryr�s��>
����B��k�k�B�G��j�j��$��>�G��\�\�&�
!�F��J�J�v�D�1�E�
�F��I��;�;�=�=�	��J�J�L��o�o�a� :�;�d�B�C�C��'�'��t�4�L��*�*�l�:�	G��6�6�,�F���H�
�!�%�6�	��:�:�i�n�n�X�6�7���:�:�e�j�j��2�3��
�
O�P�D��,�,��<���5�5��'�'�	�4�8�9��M�M��?��M�!�i�i��:��O�(*�}�}��J�(�$��#��&��3�3���� �#�!�,��!�H�,��k�k��M�N����
�k�k��!��
&�&����
�G�0�0��5�A�A�L�	� �-�-�i��?���0�0�N�B� �i�i��2N�O�O��M�M��;��M�(*�}�}��F�(�$��#��&��-�-���� �#�!�,��!�H�,��k�k��K������k�k��Q��&�	&�
�
����U�)�<�<��b�5�7����2�����b�!�4>�3H�3H��3L�M�3L�4�1�a�A�J�J�3L��M�7��;��!��/D�E�!��2�$�u�H��!���
��N�N�8�,�	����Z�;�;�<��
�
�
��J�J�x�(�	����I�&�J�

���8�
�E�
�'�'�E���y�y�H�-�b��I�H��	�,�,��<��2�2�l�B����Z�6�6�7�����=�=�>��z�z�)�$�7�H��*�*�H���
�
�:�D�9�I� �+�+�I��
�E��J�$�	��r��d���%������!�)�)���!5�!��
��"�#�t�$�$��(�(�2�U�:��
�	���S��3%�<�?�?�����t�y�y���9M�/N� O�O��D��t�U�5�\�2�
&�C���
����!�3� ���������u!�	���	��+�+��(�)�T�:�3J�3J�1�3M�,N�N��
��	��NNs$�8X
�Y#�
Y �	Y �#8Y�Y c���[R"5(dgSn[RU;a3U(a,UR	URS5URS9 SnUR	URS5URS9 SnUR	URS5URS9 SnU$![a Nff=f![a NJf=f![a U$f=f)a�Load hgrc files/content into a ui instance.

This is called during repository opening to load any additional
config files or settings relevant to the current repository.

Returns a bool indicating whether any additional configs were loaded.

Extensions should monkeypatch this function to modify how per-repo
configs are loaded. For example, an extension may wish to pull in
configs from alternate files or sources.

sharedvfs is vfs object pointing to source repo if the current one is a
shared one
F�hgrc��rootTshgrc-not-shared)r:�
use_repo_hgrcr�r��
readconfigrrr��OSError)rr�r�r+r�rgs      rTr�r�Os���*���!�!��
�C��,�,��<��	��M�M�)�.�.��1�	���M�G��C�
�
�
�
�e�j�j��)����
�=���
�
�
�
�e�j�j�!3�4�7�<�<�
�H����J���	��	���
��
���
���J�
�s5�+B?�&+C�+C�?
C�C�
C�C�
C-�,C-c	���S/S/S/S.n[UR55H@upVXS;aMUH.nURSU5(aMURSUSSS9 M0 MB g	)
a=Perform additional actions after .hg/hgrc is loaded.

This function is called during repository loading immediately after
the .hg/hgrc file is loaded and before per-repo extensions are loaded.

The function can be used to validate configs, automatically add
options (including extensions) based on requirements, etc.
�git�
largefiles�lfs)r�r�r�s
extensionsrZsautoload)r=N)r��items�	hasconfig�	setconfig)rr�r�r+�autoextensions�requirement�namesr�s        rTr�r�so����%�����N�%�^�%9�%9�%;�<����*���D��<�<�
�t�4�4����]�D�#�k��J��	=rZc�<�[[R5n[R"U5VVs1sHup#URiM nnn[
HnURU;dMU"X5 M [RH�n[RUnUR5(dM-UR5(dMDURSU-5 UR5S:XdMnUR[R5 M� U$s snnf)z6Determine the complete set of recognized requirements.�exp-compression-%s�zstd)rW�localrepository�_basesupportedrr\�featuresetupfuncsr]r6�compengines�	available�revlogheaderrlr�r��REVLOG_COMPRESSION_ZSTD)r�	supportedr�r��modulesr�r��engines        rTr�r��s����O�2�2�3�I�'1�&;�&;�B�&?�@�&?�d�a�q�z�z�&?�G�@���
�=�=�G�#��r�� �
� � ���!�!�$�'�������&�"5�"5�"7�"7��M�M�/�$�6�7��{�{�}��'��
�
�o�E�E�F�!����As�Dc�h�[5nUHYnX1;aM
U(aUSSR5(d[R"[	S55eURU5 M[ U(aB[R"[	S5SR
[U55-[	S5S9eg)	z�Validate that a set of local requirements is recognized.

Receives a set of requirements. Raises an ``error.RepoError`` if there
exists any requirement in that set that currently loaded code doesn't
recognize.

Returns a set of supported requirements.
rrs.hg/requires file is corrupts:repository requires features unknown to this Mercurial: %s� sJsee https://mercurial-scm.org/wiki/MissingRequirement for more informationr�N)rW�isalnumr�RequirementErrorrrlrrr�)r+r�missingr�s    rTr�r��s����e�G�#���#���+�a��"2�":�":�"<�"<��(�(��+J�)K�L�L����K� �$���$�$�
�K�L��i�i��w��(�
)��(��
�	
�rZc��[RU;a5[R(d[R
"[
S55egg)a�Validates that a set of recognized requirements is mutually compatible.

Some requirements may not be compatible with others or require
config options that aren't enabled. This function is called during
repository opening to ensure that the set of requirements needed
to open a repository is sane and compatible with config options.

Extensions can monkeypatch this function to perform additional
checking.

``error.RepoError`` should be raised on failure.
sfrepository is using sparse feature but sparse is not enabled; enable the "sparse" extensions to accessN)r��SPARSE_REQUIREMENTr0�enabledrr�r)rr+s  rTr�r��sA��	�*�*�l�:�����o�o�
�1�
�
�	
��	;rZc��[RU;aT[RU;a*[RU;n[R
"XU5$[R"X5$[R"X5$)z,Construct a storage object for a repository.)r��STORE_REQUIREMENT�FNCACHE_REQUIREMENT�DOTENCODE_REQUIREMENT�storemod�fncachestore�encodedstore�
basicstore)r+ro�vfstype�	dotencodes    rTr�r��sc���(�(�L�8��.�.�,�>�'�=�=��M�I��(�(��	�B�B��$�$�T�3�3����t�-�-rZc�r�0n[RU;aSUS'URSS5nUbXCS'[RU;d[RU;aUR[
XU55 OSUS'[RU;aSUS'U$URSS	5nS
nXV;aSUS'U$)z|Resolve the options to pass to the store vfs opener.

The returned dict is used to influence behavior of the storage layer.
T�treemanifest�formatsmanifestcachesizesrevlogv0�changeset-sidedatascopies-storage�experimentalscopies.write-to)schangeset-onlys
compatibilitysextra)	r��TREEMANIFEST_REQUIREMENT�	configint�REVLOGV1_REQUIREMENTr�r��resolverevlogstorevfsoptions�COPIESSDC_REQUIREMENTr�)rr+r�r��manifestcachesize�
writecopiesto�copiesextramodes       rTr�r��s���
�G��/�/�<�?�#'��� ����Y�0D�E���$�(9�$�%�	�,�,��<��/�/�<�?����3�B�h�O�P�#�����,�,��<�%:��!�"��N��	�	�/�3E�F�
�?���+�)1�G�%�&��NrZc�
�0n0US'[R"5=oCS'[R"5=oSS'[R"5=ocS'[R
U;aSUS'[RU;aSUS'[RU;aSUS'URS	S
5nXsS'[RU;aSUS'URS
S5nUbX�l[R"US5n	U	[R:�a)SUlSUlU	[R":�aSUlURSS5UlURSS5UlURSS5UlURSS5n
X�S'URSS5nSnU(a0URSS5nUc[R*"U5(+nX�lX�lUR1S	S5n
SU
::aX�l[4R6"5nURSS U5(aUR1SS!5UlURS	S"5n[;UR=S	S#55nUR1S	S$5nX�lUUl UUl![RDU;nUUl#U(aSUS'SUlSnU(a[HRJnURS
S%U5nUbUUl&UHEnURNnU"S&5(dU"S'5(dM+URQS(S)5S)Ul)MG URSS*5nUb3SUs=::aS+::d&O [US,5n[VRX"UU-5eUURZS-'URSS.5nUb3SUs=::aS/::d&O [US05n[VRX"UU-5eUURZS1'[R\U;aSUl/URS	S25(aSUS2'[R`U;Ga%UR=SS35nUS4:XaUR=SS55nUS6;aaURcSS55n[US75nUReUU-5 URf(dURe[US85U-5 Un[US95n[US:5nh(ddUS;:XaCS<U-S=-nUReU5 URf(dS>U-S?-nUReU5 US@:Xa[VRX"UUSA9eSUSB'[RjU;Ga UR=SSC5nUS4:XaUR=SS55nUS6;aaURcSS55n[USD5nUReUU-5 URf(dURe[US85U-5 Un[USE5n[USF5nRn(ddUS;:XaCS<U-S=-nUReU5 URf(dS>U-S?-nUReU5 US@:Xa[VRX"UUSA9eURSSG5(aSUSH'URSISB5(aSUSJ'U$)Kz+Resolve opener options specific to revlogs.sflagprocessorssfeature-configsdata-configsdelta-configT�revlogv1�revlogv2schangelogv2r!schangelog-v2.compute-rankschangelogv2.compute-ranksgeneraldeltarschunkcachesizeNsmemoryi'��
�storages#revlog.optimize-delta-parent-choices5revlog.delta-parent-search.candidate-group-chunk-sizesdebugsrevlog.debug-deltasrevlog.issue6528.fix-incomingsissue6528.fix-incomingsrevlog.reuse-external-deltaFs"revlog.reuse-external-delta-parentsmaxdeltachainspanrsrevlog.mmap.indexs revlog.mmap.index:size-thresholdssparse-readssparse-read.density-thresholdssparse-read.min-gap-sizesmaxchainlensrevlog-compression-sexp-compression-�-�srevlog.zlib.level�	s8invalid value for `storage.revlog.zlib.level` config: %ds
zlib.levelsrevlog.zstd.level�s8invalid value for `storage.revlog.zstd.level` config: %ds
zstd.levels
rust.indexs#revlog.persistent-nodemap.slow-path�defaults
all-slow-path)r��warnr�sMunknown value for config "storage.revlog.persistent-nodemap.slow-path": "%s"
s"falling back to default value: %s
sQaccessing `persistent-nodemap` repository without associated fast implementation.s@check `hg help config.format.use-persistent-nodemap` for detailsr5s	warning: r��(s)
r�r�r�sdirstate-v2.slow-paths7unknown value for config "dirstate-v2.slow-path": "%s"
sJaccessing `dirstate-v2` repository without associated fast implementation.s9check `hg help config.format.use-dirstate-v2` for detailssrevlog.persistent-nodemap.mmapspersistent-nodemap.mmap�develsdevel-force-nodemap)8r,�
FeatureConfig�
DataConfig�DeltaConfigr�r$r�r�r��GENERALDELTA_REQUIREMENTr#�chunk_cache_sizer/�get_resource_profile�RESOURCE_MEDIUM�uncompressed_cache_count�uncompressed_cache_factor�
RESOURCE_HIGH�delta_both_parents�candidate_group_chunk_size�debug_delta�
gddeltaconfig�
lazy_delta�lazy_delta_base�configbytes�max_deltachain_spanr6�has_mmap_populate�mmap_index_threshold�floatr��with_sparse_read�sr_density_threshold�sr_min_gap_size�SPARSEREVLOG_REQUIREMENT�
sparse_revlog�revlogconst�SPARSE_REVLOG_MAX_CHAIN_LENGTH�
max_chain_len�
startswith�split�compression_enginerrrW�compression_engine_options�NARROW_REQUIREMENT�enable_ellipsis�NODEMAP_REQUIREMENT�config_default�warn�quiet�HAS_FAST_PERSISTENT_NODEMAP�DIRSTATE_V2_REQUIREMENTr�HAS_FAST_DIRSTATE_V2)rr+r�r��feature_config�data_config�delta_config�cmp_rank�chunkcachesize�memory_profile�	issue6528�	lazydelta�
lazydeltabase�	chainspan�has_populate�withsparseread�srdensitythres�srmingapsize�sparserevlog�maxchainlen�r�prefix�
zlib_level�msg�
zstd_level�	slow_path�defaultr�s                            rTr%r%s����G�!#�G���28�2F�2F�2H�H�N�.�/�,2�,=�,=�,?�?�K�.�)�.4�.@�.@�.B�B�L�?�+��+�+�|�;�#�����+�+�|�;�#�����.�.�,�>�"&�����=�=��2N�O��/7�+�,��/�/�<�?�#'��� ��\�\�)�->�?�N��!�'5�$��1�1�"�i�@�N���0�0�0�/5��,�01��-��W�2�2�2�46�K�1�&(�m�m��:�'�L�#�/1�l�l��@�/�L�+� "�}�}�X�7L�M�L���
�
�j�*J�K�I�)2�%�&��
�
�j�*H�I�I��M���
�
��=�
�
�� � '� 5� 5�b� 9�9�M�'��#0� �����0D�E�I��I�~�+4�(��)�)�+�L�	�}�}�Z�!5�|�D�D�+-�>�>��/�,
��(�
�]�]�?�N�C�N��
�	�	�/�#C�D��N��>�>�/�3N�O�L�#1� �'5�K�$�".�K��"�;�;�|�K�L�!-�L���#'��� �'+��$��K��!�@�@���,�,�y�.�+�F�K���%0��"�
��
�����(�)�)�V�4G�-H�-H�01����a�0@��0C�N�-�����j�*>�?�J����Z�$�1�$��O�P�C��+�+�c�J�.�/�/�?I�N�-�-�m�<����j�*>�?�J����Z�%�2�%��O�P�C��+�+�c�J�.�/�/�?I�N�-�-�m�<��)�)�\�9�)-��&�	�}�}�_�m�4�4�!%��
���*�*�l�:��I�I��>�
�	��
�"��	�	�*�.>�?�I��9�9��'�'�
�4D�E�G��I��C�
�G�G�C�)�O�$��8�8�����@�A�G�K�L��I��
$�
���
�
���1�1��G�#�"�S�(�5�0��������x�x��$�;��/�D��G�G�D�M��H�$��k�k�#�D�1�1�)-��%�&��.�.�,�>��I�I�j�*B�C�	��
�"��	�	�*�.>�?�I��9�9��'�'�
�4D�E�G��O�P�C��G�G�C�)�O�$��8�8�����@�A�G�K�L��I��
$�
���L�
���,�,��G�#�"�S�(�5�0��������x�x��$�;��/�D��G�G�D�M��H�$��k�k�#�D�1�1�	�}�}�Z�!B�C�C�.2��*�+�	�}�}�X�4�5�5�*.��&�'��NrZc��[$)z6Produce a type conforming to ``ilocalrepositorymain``.)r)r�s rT�makemainrz�s���rZc��\rSrSrSrSrSrg)�revlogfilestoragei�z File storage when using revlogs.c���URS5(aUSSnUR5SL=(d  [R"UR5n[
R
"URXS9$�N�/r)�	try_split)rU�currenttransactionr5�mayhavependingr�r�svfs�rOror�s   rT�file�revlogfilestorage.file�sb���?�?�4� � ����8�D�
�#�#�%�T�1�
1��%�%�d�i�i�0�	�
���t�y�y�$�D�DrZr[N�r\r]r^r_r`r�rar[rZrTr|r|�s��*�	ErZr|c��\rSrSrSrSrSrg)�revlognarrowfilestoragei�z1File storage when using revlogs and narrow files.c��URS5(aUSSnUR5SL=(d  [R"UR5n[
R"URXRUS9$r~)	rUr�r5r�r�r�
narrowfilelogr��_storenarrowmatchr�s   rTr��revlognarrowfilestorage.file�sq���?�?�4� � ����8�D�
�#�#�%�T�1�
1��%�%�d�i�i�0�	��$�$��I�I�t�3�3�y�
�	
rZr[Nr�r[rZrTr�r��s
��;�

rZr�c��UR[R5 UR[R5 [R
U;a[$[$)z=Produce a type conforming to ``ilocalrepositoryfilestorage``.)rlr;� REPO_FEATURE_REVLOG_FILE_STORAGEr�r�rYr�r|)r+r�r�s   rT�makefilestorager��s@���L�L��<�<�=��L�L��5�5�6��)�)�\�9�&�&� � rZc��[$rG)rzr[rZrTr�r�s��hrZc��[$rG)r�r[rZrTr�r�s��_rZc�F�\rSrSrSr\R\R\R\R\R\R\R\R\R\R\R \R"\R$\R&\R(\R*\R,\R.\R0\R21r1SkrS�S�SjjrSrSr\S5r S	r!S
r"Sr#\S5r$\S
5r%Sr&S�Sjr'Sr(S�Sjr)\*"SSSS5S5r+Sr,\S5r-\."SS5S5r/\."S5S5r0\1"5S5r2\3"5S5r4\5S 5r6S!r7S"r8\."\9Rt5S#5r;\."\9Rt5S$5r<\."\9Rt5S%5r=S�S&jr>S'r?\5S(5r@\5S)5rA\BS*5rC\S+5rDS,rES-rFS.rG\GrHS/rIS0rJS�S1jrKS�S2jrLS�S�S3jjrMS�S4jrNS�S5jrO\PS65rQS7rRS8rSS9rTS:rUS;rVS<rWS=rX\BS>5rYS?rZS�S@jr[SAr\SBr]SCr^SDr_SEr`SFraSGrbS�SHjrcS�SIjrdS�S�SJjjreS�SKjrfS�S�SLjjrgSMrhSNri\5SO5rj\5SP5rkSQrlS�SRjrmS�S�SSjjrnS�STjroSUrpS�SVjrqSWrrSXrs\BSY5rtSZruS�S[jrv\BS\5rwS]rx\BS�S^j5ryS_rzS`r{Sar|S�Sbjr}Scr~\BSd5rS�Sejr�Sfr�S�Sgjr�S�Shjr�Sir�Sjr�Skr�Slr�\BS�Smj5r�\BS�Snj5r�\BSo5r�\BSp5r�S�Sqjr�Srr�Ssr�Str�S�Sujr�S�Svjr�Swr�Sxr�Syr�\5Sz5r�S{r�S|r�S�S}jr�S~r�Sr�S�S�jr�S�r�g)�ria)Main class for representing local repositories.

All local repositories are instances of this class.

Constructed on its own, instances of this class are not usable as
repository objects. To obtain a usable repository object, call
``hg.repository()``, ``localrepo.instance()``, or
``localrepo.makelocalrepository()``. The latter is the lowest-level.
``instance()`` adds support for creating new repositories.
``hg.repository()`` adds more extension integration, including calling
``reposetup()``. Generally speaking, ``hg.repository()`` should be
used.
>r��cache/�requires�bisect.stateNc���XlX lX0lX@lURUlXPlURUlX`l[Ul
URRUlXplX�l
X�lX�lX�lX�lSUlURR'SS5(d!URR'SS5(a4UR)URR*5URl/Ul[.R0"UR5 URRUlURRUlURR6UlURR'SS5(d!URR'SS5(a�[;UR4S5(aIUR=UR4RR*5UR4RlO4UR=UR4R*5UR4lSUl[@RB"5Ul"SUl#0Ul$0Ul%S=Ul&=Ul'Ul(0Ul)0Ul*SUl+/Ul,SUl-SUl.[^R^"5Ul00Ul10Ul2[fRh"U5Ul5SUl6[nRpUR;aSUl6[s5Ul:0Ul;[xRz"U5 g)a�Create a new local repository instance.

Most callers should use ``hg.repository()``, ``localrepo.instance()``,
or ``localrepo.makelocalrepository()`` for obtaining a new repository
object.

Arguments:

baseui
   ``ui.ui`` instance that ``ui`` argument was based off of.

ui
   ``ui.ui`` instance for use by the repository.

origroot
   ``bytes`` path to working directory root of this repository.

wdirvfs
   ``vfs.vfs`` rooted at the working directory.

hgvfs
   ``vfs.vfs`` rooted at .hg/

requirements
   ``set`` of bytestrings representing repository opening requirements.

supportedrequirements
   ``set`` of bytestrings representing repository requirements that we
   know how to open. May be a supetset of ``requirements``.

sharedpath
   ``bytes`` Defining path to storage base directory. Points to a
   ``.hg/`` directory somewhere.

store
   ``store.basicstore`` (or derived) instance providing access to
   versioned storage.

cachevfs
   ``vfs.vfs`` used for cache files.

wcachevfs
   ``vfs.vfs`` used for cache files related to the working copy.

features
   ``set`` of bytestrings defining features/capabilities of this
   instance.

intents
   ``set`` of system strings indicating what this repo will be used
   for.
Nr7�all-warnings�check-locksr7Fr )>r�rr��wvfsr�r�r7ror+r�
nodeconstants�nullidrr�r1r�r�r��
filternamer��_getvfsward�audit�_phasedefaultsr�setup�spathr�rrr~r_�_getsvfsward�_dirstatevalidatewarnedr�BranchMapCache�
_branchcaches�_revbranchcache�_filterpats�_datafilters�	_transref�_lockref�	_wlockrefr��filteredrevcache�	_dirstate�
_postdsstatus�_pending_narrow_pats�_pending_narrow_pats_dirstater"r��_sparsesignaturecache�_sparsematchercacher*�extrafilter�_extrafilterid�filecopiesmoder�r&rWr�_sidedata_computers�sidedatamod�set_sidedata_spec_for_repo)rOr�rr�r�r�r+r�r�r1r�r�r�r�s              rTrj�localrepository.__init__Us���H���� �
��	��L�L��	����J�J��	�(��.����(�(�/�/���.��$���
� �
�"�� �
�����7�7���h��8�8�D�G�G�<N�<N��n�=
�=
�"�-�-�d�h�h�n�n�=�D�H�H�N�!���
���D�G�G���Z�Z�_�_��
��J�J�N�N��	��Z�Z�_�_��
��7�7���h��8�8�D�G�G�<N�<N��n�=
�=
��t�y�y�%�(�(�&*�&7�&7��	�	�
�
�8K�8K�&L��	�	�
�
�#�"&�"3�"3�D�I�I�O�O�"D��	�	��',��$�&�5�5�7���#���������:>�>���>��������!#���������$(��!�-1��*� �*�*�,��
�&(��"�#%�� �&�2�2�2�6���"����0�0�D�4E�4E�E�"7�D�� #����#%�� ��.�.�t�4rZc�L^^^�[R"T5mSUUU4SjjnU$)zbuild a ward for self.vfsc��>^�T"TUS9nT"5nUb"[US5(a[US5(dgUS;agTRUR5(aT[UR5S-SmTRS5(a SnURRUT-SS	S
9 Sn[
U4SjU55(a<URUR5cURRS
T-SSS
9 U$URUR5cIT	RHnTRU5(dM g URRST-SSS
9 U$)N��moder�r��N�rsrbrr�s2accessing cache with vfs instead of cachevfs: "%s"�s	cache-vfs)�
stacklevelr�)sjournal.sundo.s
strip-backup/r�c3�F># �UHnTRU5v� M g7frG)rU)�.0rsros  �rT�	<genexpr>�@localrepository._getvfsward.<locals>.checkvfs.<locals>.<genexpr>s����K�9J�v�4�?�?�6�*�*�9J�s�!�write with no lock: "%s"r�swrite with no wlock: "%s")r_rUro�lenr�	develwarn�any�_currentlockr�r��_wlockfreeprefix)
ror�rgrPru�vfs_path_prefixesrs�origfunc�rrefrOs
`      ���rT�checkvfs�-localrepository._getvfsward.<locals>.checkvfs�sh����4�d�+�C��6�D����t�[�1�1��t�Z�0�0���*�*�����t�y�y�)�)��C��	�	�N�Q�.�0�1�����y�)�)�K�����!�!�#��*��<�!�P�!���K�9J�K�K�K��$�$�T�]�]�3�;��G�G�%�%�3�d�:�#$�-�&��"�J��"�"�4�>�>�2�:�#�3�3�F����v�.�.��4����!�!�0�4�7� �)�"��
�JrZrG��weakref�ref)rOr�r�r�s`` @rTr��localrepository._getvfsward�s#����{�{�4� ��+	�+	�Z�rZc�H^^�[R"U5mSUU4SjjnU$)zbuild a ward for self.svfsc�B>�T"XS9nT"5nUb[US5(dgUS;agURUR5(aU[UR5S-SnUR	UR
5cURRSU-SS9 U$)Nr�r�r�rr�r-)r�)r_rUr�r�r�r�rr�)ror�rgrPr�r�s    ��rT�	checksvfs�/localrepository._getsvfsward.<locals>.checksvfs+s�����4�+�C��6�D��|�7�4��#<�#<���*�*�����t���/�/��C����0�1�4�6�7��� � ����/�7����!�!�/�$�6�1�"���JrZrGr�)rOr�r�r�s ` @rTr��localrepository._getsvfsward's#����{�{�4� ��	�	� �rZc�J�URURURS.$)N)rZrhr��r�r7r�s rT�vfs_map�localrepository.vfs_map=s#������h�h��i�i�
�	
rZc�$�UR5 grG)�_writecachesr�s rTr��localrepository.closeEs�����rZc�\�UR(aURR5 ggrG)r��writer�s rTr��localrepository._writecachesHs"������ � �&�&�(� rZc�~�URRSS5(a[[U5n[R"[R
"USS95nUR
S[RU5-5 URRSS5(aUR
[R5 U$)Nr!sbundle2-advertisesclient)�rolesbundle2=snarrow)rr�rWr�
encodecaps�getrepocapsrl�urlreq�quoter8�	NARROWCAP)rOr	�capsblobs   rTr�%localrepository._restrictcapabilitiesLs����7�7���o�/C�D�D��t�9�D��)�)��#�#�D�y�9��H�
�H�H�[�6�<�<��#9�9�:��7�7���o�y�9�9��H�H�^�-�-�.��rZc�T�[R"URURS9$)N)�callback�r%�pathauditorr��_checknestedr�s rT�auditor�localrepository.auditorZs!���#�#�D�I�I��8I�8I�J�JrZc�X�[R"URURSSS9$)NFT)r��realfs�cachedr�r�s rT�nofsauditor�localrepository.nofsauditor`s*���#�#��I�I�� 1� 1�%��
�	
rZc���URUR5(dgU[UR5S-Sn[R"U5nUSn[R
"U5nU(apSR
U5nXdR;a7Xc:XagURU5nURU[U5S-S5$UR5 U(aMpg)z/Determine if path is a legal nested repository.FrNrT)rUr�r�r6�pconvert�	splitpathrr�substate�sub�checknested�pop)rOro�subpath�normsubpath�ctx�partsrsr�s        rTr��localrepository._checknestedhs������t�y�y�)�)���s�4�9�9�~��)�+�,���m�m�G�,��&�4�j�����w�'����Y�Y�u�%�F����%��(���'�'�&�/�C��?�?�7�3�v�;��?�3D�+E�F�F��	�	���e�rZc��[XUS9$)Nr�)r�)rOror�s   rTr��localrepository.peer�s����,�
�	
rZc��U$)zYReturn unfiltered version of the repository

Intended to be overwritten by filtered repo.r[r�s rTrH�localrepository.unfiltered�s	���rZc��URbSU;aUS-UR-n[R"UR5R5nU"XU5$)a�Return a filtered version of a repository

The `name` parameter is the identifier of the requested view. This
will return a repoview object set "exactly" to the specified view.

This function does not apply recursive filtering to a repository. For
example calling `repo.filtered("served")` will return a repoview using
the "served" view, regardless of the initial view used by `repo`.

In other word, there is always only one level of `repoview` "filtering".
�%)r�r*�newtyperHrS)rOr��visibilityexceptionsr�s    rTr�localrepository.filtered�sV�����*�t�4�/?��$�;��!4�!4�4�D����t���0�:�:�;���4�3�4�4rZ)�	bookmarksrh)sbookmarks.currentrh)rrZr�c�N�UR5 [R"U5$rG)�_refreshchangelogr�bmstorer�s rT�
_bookmarks�localrepository._bookmarks�s"��n	
��� �� � ��&�&rZc�L�S[U5;aUR5cU?ggg)z7make sure the in memory changelog match the on-disk one�	changelogN)r�r�rr�s rTr�!localrepository._refreshchangelog�s*���$�t�*�$��)@�)@�)B�)J���*K�$rZc�.�URR$rG)r�activer�s rT�_activebookmark�localrepository._activebookmark�s�����%�%�%rZs
phaserootsr�c�B�[R"XR5$rG)r&�
phasecacher�r�s rT�_phasecache�localrepository._phasecache�s��� � ��':�':�;�;rZsobsstorec�D�[R"URU5$rG)r$r�rr�s rT�obsstore�localrepository.obsstore�s���!�!�$�'�'�4�0�0rZc���URR5 URR[R
"UR5[R"URS5S9$)N�	changelog)�concurrencychecker)
r�prefetch_parentsr1rr5r�r��
revlogchecker�get_checkerr)rPs rTr�localrepository.changelog�sV��	
�
�
�&�&�(��z�z�#�#��"�"�4�9�9�-�,�8�8����,�O�$�
�	
rZc�L�URRXR5$rG)r1�manifestlogr�r�s rTr+�localrepository.manifestlogs���z�z�%�%�d�,B�,B�C�CrZc��URc!UR5UlUR$URR5 UR$rG)r��
_makedirstate�refreshr�s rTr�localrepository.dirstatesD���>�>�!�!�/�/�1�D�N��~�~��
�N�N�"�"�$��~�~�rZc�`^�Sn[R"T5(aU4Sjn[Rn[RnUTR
;nUTR
;n[R"TRTRTRTRUTRUUS9$)z3Extension point for wrapping the dirstate per-repo.Nc�0>�[R"T5$rG)r0�matcherr�s�rTr��/localrepository._makedirstate.<locals>.<lambda>s���F�N�N�4�$8rZ)�use_tracked_hint)r0�
use_sparser�r`�DIRSTATE_TRACKED_HINT_V1r+rr7rr��_dirstatevalidater�)rO�
sparsematchfn�v2_req�th�use_dirstate_v2r5s`     rTr.�localrepository._makedirstates�����
����T�"�"�8�M� �8�8��
�
5�
5�� �D�$5�$5�5����!2�!2�2��� � ��H�H��G�G��I�I��"�"������-�	
�		
rZc���SnURRU5 U(aU$UR(d7SUlURR[S5[U5-5 UR$![Raa UR	5cKUR5 URRU5 N�![Ra SnN�f=fSnN�f=f)NTFs-warning: ignoring unknown working parent %s!
)r�revr�LookupError�currentlock�
invalidater�rr]rr
r�)rO�node�okays   rTr8�!localrepository._dirstatevalidate#s�����	��N�N���t�$�$��K��/�/�/3��,�������G�H��D�k�"���;�;���5� � �	����!�)����!�!��N�N�&�&�t�,���(�(�!� �D�!����!	�s/�A<�<5C1�2C�C)�%C1�(C)�)C1�0C1c�P�URnUc[R"U5nU$)zTmatcher patterns for this repository's narrowspec

A tuple of (includes, excludes).
)r�r#�load)rO�vals  rT�
narrowpats�localrepository.narrowpatsCs'���'�'���;��/�/�$�'�C��
rZc���[RUR;a[R"5$UR
up[R"URXS9$�N)�include�exclude)	r�rYr+�matchmod�alwaysrIr#rr��rOrMrNs   rTr��!localrepository._storenarrowmatchOsF���-�-�T�5F�5F�F��?�?�$�$��?�?�������	�	�7�L�LrZc���[RUR;a[R"5$[
R"U5 URup[
R"URXS9$rL)
r�rYr+rOrPr#�checkworkingcopynarrowspecrIrr�rQs   rT�_narrowmatch�localrepository._narrowmatchVsT���-�-�T�5F�5F�F��?�?�$�$��-�-�d�3��?�?�������	�	�7�L�LrZc�l�U(a�U(a{URR5(d\[R"UR	55n[R
"URU/5n[R"X5$[R"XR5$UR$)z�matcher corresponding the the repo's narrowspec

If `match` is given, then that will be intersected with the narrow
matcher.

If `includeexact` is True, then any exact matches from `match` will
be included even if they're outside the narrowspec.
)rUrPrO�exact�files�unionmatcher�intersectmatchers)rOr�includeexact�em�nms     rT�narrowmatch�localrepository.narrowmatch^s�����D�$5�$5�$<�$<�$>�$>��^�^�E�K�K�M�2���*�*�D�,=�,=�r�+B�C���1�1�%�<�<��-�-�e�5F�5F�G�G�� � � rZc�P�[R"XU5 URSS9 g�NT)�clearfilecache)r#�saverB)rO�newincludes�newexcludess   rT�
setnarrowpats�localrepository.setnarrowpatsqs������;�7����t��,rZc��S[URR4[[URR4UR[UR40$)N�null)rr�r�r�s rT�_quick_access_changeid_null�+localrepository._quick_access_changeid_nullusL��
�g�t�1�1�8�8�9��g�t�1�1�8�8�9��K�K�'�4�;�;�/�
�	
rZc��URR5nUR5RnURR5HnX0R:XaMURRU5nUcM4XC4nXQU'XQU'URU5H+nU[:XaMURU5nXg4nXQU'XQU'M- M� URR5nX�R:waXUS'U$)N�.)
rkrrHrr�parentsr��index�get_rev�
parentrevsrrC�p1)	rO�quick�clrCr?�pairrrr��p1nodes	         rT�_quick_access_changeid_wc�)localrepository._quick_access_changeid_wc}s����0�0�5�5�7��
�_�_�
�
(�
(���M�M�)�)�+�D��{�{�"���(�(�"�"�4�(�C��{���;�D��#�J��$�K��]�]�3�'����<���G�G�A�J���v���a���a��
(�,�(���!�!�#���[�[� ��-�E�$�K��rZc�>�S[U5;aURS	gg)Nrx)r�rIr�s rT�!_quick_access_changeid_invalidate�1localrepository._quick_access_changeid_invalidate�s ��&�$�t�*�4��
�
�9�:�5rZc�n�UR[R;aUR$UR$)z�an helper dictionnary for __getitem__ calls

This contains a list of symbol we can recognise right away without
further processing.
)r�r*�
filter_has_wcrxrkr�s rT�_quick_access_changeid�&localrepository._quick_access_changeid�s.���?�?�h�4�4�4��1�1�1��/�/�/rZc	��Uc[R"U5$[U[R5(aU$[U[5(aN[UR
[U556Vs/sH"nX RR;dMXPM$ sn$URRU5nUbUupE[R"XUSS9$US:XaLURR5nURRU5n[R"XU5$[U[5(aURR!U5nUnGOUS:XaDUR"R%5nUR'5RRU5nO�[U5UR(R*:XaUnURRU5nO�[U5SUR(R*-:Xa'[?U5nURRU5nO8[,R@"SU[BRD"[GU554-5e[R"XU5$s snf![,R.a
 [1U5ne[2az UR55(aXXR'5R"R75;a-[9S5n[,R:"U[=U5-5e[1U5nef=f![,RH[,R.4a7 [,RJ"[9S5[BRD"U5-5e[L[24a7 [,RN"[9S	5[BRD"U5-5e[,RPa [R"U5s$f=f)
NF)�maybe_filtered�tiprns*working directory has unknown parent '%s'!r1s$unsupported changeid '%s' of type %ssfiltered revision '%s'�unknown revision '%s'))r�
workingctxr��basectx�slice�range�indicesr�r�filteredrevsrr��	changectx�tipr?�intrCrrsrHr��nodelenr�FilteredLookupErrorr
r@rrorrWr
r	r�r)r)rQ�FilteredIndexError�FilteredRepoLookupError�
IndexError�RepoLookupError�WdirUnsupported)rO�changeid�i�quick_accessr?rCrus       rT�__getitem__�localrepository.__getitem__�sS�����%�%�d�+�+��h����0�0��O��h��&�&��� 0� 0��T�� ;�<��<�A��N�N�7�7�7����<��
��2�2�6�6�x�@���#�$�I�C��$�$�T��U�K�K��v���>�>�%�%�'�D��.�.�$�$�T�*�C��$�$�T��5�5�2	,��(�C�(�(��~�~�*�*�8�4�����T�!��}�}�'�'�)���o�o�'�1�1�5�5�d�;���X��$�"4�"4�"<�"<�<��#�D��.�.�,�,�X�6�C�$�X��!�d�&8�&8�&@�&@�"@�@��8�}���n�n�(�(��.���,�,�;���!1�!1�$�x�.�!A�B�C���
�$�$�T��5�5��q��<�0�0��"�8�}�H��"���
�
���$���(9�(B�(B�(J�(J�(L�L�� M�N��#�k�k�#��h��*?�@�@�"�8�}�H����2�(�(�%�*C�*C�D�	��/�/��+�,�x�/?�/?��/I�I��
��K�(�	��'�'��*�+�h�.>�.>�x�.H�H��
��$�$�	,��%�%�d�+�+�	,�s:�2J�J�)B!L0�J
�(BL0�
B#L-�-L0�0CO;�:O;c�B�X g![Ra gf=f)z!True if the given changeid existsTF)rr�)rOr�s  rT�__contains__�localrepository.__contains__�s'��	��N����$�$�	��	�s���c��gr�r[r�s rT�__nonzero__�localrepository.__nonzero__rrZc�L�UR5n[UR5$rG)rHr�r�rOrRs  rT�__len__�localrepository.__len__s����� ���4�>�>�"�"rZc�,�[UR5$rG)�iterrr�s rT�__iter__�localrepository.__iter__
s���D�N�N�#�#rZc�h�[R"U/UQ76n[R"U5"U5$)a�Find revisions matching a revset.

The revset is specified as a string ``expr`` that may contain
%-formatting to escape certain types. See ``revsetlang.formatspec``.

Revset aliases from the configuration are not expanded. To expand
user aliases, consider calling ``scmutil.revrange()`` or
``repo.anyrevs([expr], user=True)``.

Returns a smartset.abstractsmartset, which is a list-like interface
that contains integer revisions.
)r.�spectreer-�makematcher)rO�exprr��trees    rT�revs�localrepository.revss/���"�"�4�/�$�/���!�!�$�'��-�-rZc'�L# �UR"U/UQ76H	nXv� M g7f)a.Find revisions matching a revset and emit changectx instances.

This is a convenience wrapper around ``revs()`` that iterates the
result and is a generator of changectx instances.

Revset aliases from the configuration are not expanded. To expand
user aliases, consider calling ``scmutil.revrange()``.
N)r�)rOr�r�rrs    rTrW�localrepository.set s&������4�'�$�'�A��'�M�(�s�"$c�x�US/:Xa"[/5$US/:Xa8URR	S5nUb[R"US/5$U(a6[R
"URU[R"U5US9nO[R
"SXS9nU"U5$)aFind revisions matching one of the given revsets.

Revset aliases from the configuration are not expanded by default. To
expand user aliases, specify ``user=True``. To provide some local
definitions overriding user aliases, set ``localalias`` to
``{name: definitionstring}``.
rjrnNr)rN�
localalias)r�)r-�basesetrrr��matchanyr�lookupfn)rO�specs�userr��
quick_datar�s      rT�anyrevs�localrepository.anyrevs,s����W�I���>�>�7�)�,�,��T�F�?��4�4�8�8��>�J��%��~�~�z�!�}�o�6�6������������t�,�%�	�A�����e�C�A���w�rZc� �SUR-$)Nsfile:r�r�s rTr
�localrepository.urlEs���$�)�)�#�#rZc�H�[R"URXU40UD6$)z�Call a hook, passing this repo instance.

This a convenience method to aid invoking hooks. Extensions likely
won't call this unless they have registered a custom hook or are
replacing code that is expected to call a hook.
)rr)rOr��throwr�s    rTr�localrepository.hookHs ���y�y����$�e�<�t�<�<rZc�b�"SS5nU"5nUR5uUlUlU$)zEReturns a tagscache object that contains various tags related
caches.c��\rSrSrSrSrg)�-localrepository._tagscache.<locals>.tagscacheiXc�<�S=UlUlS=UlUlgrG)r3�tagtypes�
nodetagscache�tagslistr�s rTrj�6localrepository._tagscache.<locals>.tagscache.__init__Ys!��-1�0��	�D�M�59�9��"�T�]rZ)r�r3r�r�N)r\r]r^r_rjrar[rZrT�	tagscacher�Xs��
:rZr�)�	_findtagsr3r�)rOr��caches   rT�
_tagscache�localrepository._tagscacheQs/��		:�		:����%)�^�^�%5�"��
�E�N��rZc�L�0nURR(aUR5up#OURRnURR
nUR
5HupVU"U5 XaU'M U$![R[4a M5f=f)zreturn a mapping of tag to node)
rr�r�r�r3r?r�rr@r�)rO�tr3�ttr?�k�vs       rTr3�localrepository.tagshs������>�>�&�&��~�~�'�H�D�"��?�?�'�'�D��n�n� � ���J�J�L�D�A�
��A���!��	!�����%�%�z�2�
��
�s�3B�B#�"B#c��[R"URU5nUVs0sHo"S_M nn[R"URXU5 0nUR	5H1unupgX`R
:wdMXd[R"U5'M3 URR5US'UR	5VVs0sHupX[R"U5U_M nnnXC4$s snfs snnf)aMDo the hard work of finding tags.  Return a pair of dicts
(tags, tagtypes) where tags maps tag name to node, and tagtypes
maps tag name to a string like 'global' or 'local'.
Subclasses or extensions are free to add their own tags, but
should be aware that the returned dicts will be retained for the
duration of the localrepo object.sglobalr�)
�tagsmod�findglobaltagsr�
readlocaltagsr�r�r�tolocalrr�)	rO�alltags�tagr�r3r�rC�histrXs	         rTr��localrepository._findtagsys����(�(����$�7��.5�6�g�s��N�g��6����d�g�g�t�h�?���")�-�-�/��D�,�4��{�{�"�/3�X�%�%�d�+�,�#2��~�~�)�)�+��V��?G�~�~�?O�
�?O�m�t�H���T�"�E�)�?O�	�
�����!7��
s�C6�
#C;c�L�URRRU5$)z�
return the type of the given tag. result can be:

'local'  : a local tag
'global' : a global tag
None     : tag does not exist
)r�r�r�)rO�tagnames  rT�tagtype�localrepository.tagtype�s�����'�'�+�+�G�4�4rZc��URR(d�/nUR5R5H1up#UR	UR
R
U5X#45 M3 [U5VVVs/sH	upBo2U4PM snnnURlURR$s snnnf)z)return a list of tags ordered by revision)r�r�r3r�r�rr?r�)rO�lr�r�rrs     rTr��localrepository.tagslist�s������'�'��A��	�	��)�)�+������$�.�.�,�,�Q�/��6�7�,�>D�Q�i�'H�i�7�1��A��i�'H�D�O�O�$����'�'�'��(Is�B:c��URR(d�0nURRR5H&up4UR	U/5RU5 M( UR
5HnUR5 M X RlURRRU/5$)z&return the tags associated with a node)	r�r�r3r��
setdefaultr��values�sortr�)rOrCr�r�r�r3s      rT�nodetags�localrepository.nodetags�s������,�,��M����,�,�2�2�4����(�(��B�/�6�6�q�9�5�%�,�,�.���	�	��/�,9�O�O�)����,�,�0�0��r�:�:rZc�8�URRU5$)z;return the list of bookmarks pointing to the specified node)rr�)rOrCs  rT�
nodebookmarks�localrepository.nodebookmarks�s�����$�$�T�*�*rZc� �URU$)zcreturns a dictionary {branch: [branchheads]} with branchheads
ordered by increasing revision number)r�r�s rTr�localrepository.branchmap�s���!�!�$�'�'rZc��UR(d+UR5n[R"U5UlUR$rG)r�rH�rev_branch_cache�revbranchcacher�s  rTr��localrepository.revbranchcache�s6���#�#��?�?�$�D�#3�#B�#B�4�#H�D� ��#�#�#rZc�B�UR5RX5 grG)r��setdata)rOr?�changelogrevisions   rT�register_changeset�"localrepository.register_changeset�s������%�%�c�=rZc��UR5RU5$![a, U(d"[R"[S5U-5egf=f)z�return the tip node for a given branch

If ignoremissing is True, then this method will not raise an error.
This is helpful for callers that only expect None for a missing branch
(e.g. namespace).

sunknown branch '%s'N)r�	branchtiprKrr�r)rO�branch�
ignoremissings   rTr��localrepository.branchtip�sP��	��>�>�#�-�-�f�5�5���	� ��+�+�A�.D�,E��,N�O�O��		�s�!�3A�Ac��[R"X5R5nUc"[R"[S5U-5eU$)Nr�)r/�	revsymbolrCrr�r)rOrPrCs   rTrN�localrepository.lookup�sA��� � ��+�0�0�2���<��'�'��*B�(C�c�(I�J�J��rZc��UR5RU5(aU$[R"X5R	5$rG)r�	hasbranchr/r�r�rOs  rT�lookupbranch�localrepository.lookupbranch�s9���>�>��%�%�c�*�*��J�� � ��+�2�2�4�4rZc���URnURRnURn/nUH0nU"U5nUSL=(d Xt;(+nUR	U5 M2 U$rG)rrprqr�r�)	rOrGrurqrr�r�rr�resps	         rTrE�localrepository.known�sa��
�^�^���(�(�"�"���?�?�����A���
�A��T�	�2�Q�]�3�D��M�M�$����
rZc��U$rGr[r�s rTr�localrepository.local�r�rZc�8�URRSSSS9$)N�phasesspublishT)�	untrusted)rr�r�s rT�
publishing�localrepository.publishing�s ���w�w�!�!�)�Z�4�!�H�HrZc��UR5(dgUR5(dgURS5RR(+$)NFT�visible)rrrrr�r�s rT�cancopy�localrepository.cancopy�s>���z�z�|�|����� � ���=�=��,�6�6�C�C�C�CrZc�:�URUR:wagg)z2the type of shared repository (None if not shared)r�N)r�ror�s rTr��localrepository.shared	s���?�?�d�i�i�'��rZc�R�URR"URU/UQ76$rG)r7�reljoinr�)rOr��insidefs   rT�wjoin�localrepository.wjoin
	s"���x�x����	�	�1�7�w�7�7rZc�j�UcURnUSRX5 UR5 grG)r��
setparentsr{)rOrs�p2s   rTr�localrepository.setparents	s.��
�:����B��T�
���b�%��.�.�0rZc�.�[R"XX#US9$)z[changeid must be a changeset revision, if specified.
fileid can be a file revision or node.)r�)r�filectx)rOror��fileidr�s     rTr�localrepository.filectx	s�������I�
�	
rZc�6�URR5$rG)r�getcwdr�s rTr!�localrepository.getcwd	s���}�}�#�#�%�%rZc�8�URRX5$rG)r�pathto)rOr��cwds   rTr$�localrepository.pathto 	s���}�}�#�#�A�+�+rZc�t�XR;Ga/nURRU5H�up4US:XaM
[R"UR
SU/5nSnUnURR5H;up�URU5(dMU	nU[U5SR5n O U(d
SnSUl[R"U5S(dUn
U
4SjnSU
R-UlURXVU45 M� X RU'URU$)N�!rZc�.�[R"X5$rG)r=�filter)�s�cr�s   rTr��-localrepository._loadfilter.<locals>.<lambda>2	s
������0ErZ�
commandfilterr1c��U"X5$rGr[)r+r,�oldfnr�s    rTr�r-7	s��U�1�[rZzcompat-)r�r�configitemsrOrr�r�r�rUr��lstripr\r)�
getargspecr�)rOr*r��pat�cmd�mfr��paramsr��filterfnr0s           rT�_loadfilter�localrepository._loadfilter#	s���)�)�)��A� �G�G�/�/��7����$�;���^�^�D�I�I�s�S�E�:������&*�&7�&7�&=�&=�&?�N�D��~�~�d�+�+�%��!$�S��Y�[�!1�!8�!8�!:���	'@�
�E�B�"1�B�K��*�*�2�.�q�1��E�,1�H�B�"+�e�n�n�"<�B�K����"�&�)�*�'8�(()���V�$�����'�'rZc	���UHnupEnU"U5(dMURRSX&=(d  [R"UR54-5 U"X6URXS9n U$ U$)Nsfiltering %s through %s
)rrP�filename)r�debugr)�sysbytesr\)rO�
filterpatsr<�datar6r�r5s       rT�_filter�localrepository._filter=	so��%�K�B�C��(�|�|����
�
�0��!F��(9�(9�"�+�+�(F�G�H���$����d�N�����&��rZc�$�URS5$)Nsencode�r9r�s rT�_encodefilterpats�!localrepository._encodefilterpatsI	������	�*�*rZc�$�URS5$)NsdecoderDr�s rT�_decodefilterpats�!localrepository._decodefilterpatsM	rGrZc� �X RU'grG)r�)rOr�r*s   rT�
adddatafilter�localrepository.adddatafilterQ	s��"(���$�rZc���URRU5(aURRU5nOURRU5nUR	UR
X5$rG)r��islink�readlinkr�rArE�rOr<r@s   rT�wread�localrepository.wreadT	sT���9�9���H�%�%��9�9�%�%�h�/�D��9�9�>�>�(�+�D��|�|�D�2�2�H�C�CrZc�T�URURX5nSU;aURRX!5 O`URR"X4SU0UD6 SU;aURRUSS5 OURRUSS5 [
U5$)zpwrite ``data`` into ``filename`` in the working directory

This returns length of written (maybe decoded) data.
�l�backgroundclose�xFT)rArIr��symlinkr��setflagsr�)rOr<r@�flagsrVr�s      rT�wwrite�localrepository.wwrite[	s����|�|�D�2�2�H�C���5�=��I�I���d�-��I�I�O�O��
�0?�
�CI�
��u�}��	�	�"�"�8�U�D�9��	�	�"�"�8�U�E�:��4�y�rZc�:�URURX5$rG)rArIrQs   rT�
wwritedata�localrepository.wwritedatat	s���|�|�D�2�2�H�C�CrZc��UR(aUR5nOSnU(aUR5(aU$g)z4return the current transaction or None if non existsN)r��running)rO�trs  rTr��"localrepository.currenttransactionw	s/���>�>����!�B��B�
�"�*�*�,�,��I�rZc�^^^^^^�URRSS5(d!URRSS5(a2URUR5c[R
"S5eUR
5mTbTRTS9$URRS5(a'[R"[S5[S5S	9eURR(aS
n[R
"U5eS[R"5[R"54-n[!["R$"U5R'55nSU-nUR)S
STUS9 UR+T5 U(aUnOURR,nUR.n[0R2"U5mSmURRSS5n	TS:wa(U	(a!UR4R75mUU4SjmUUUU4Sjn
U4Sjn[8R8"UURUSSSUR:R<U
U[>TS9mURA5Hup�TRCX�5 M [EU5TRFS'[I5TRFS'/TRFS'0TRFS'UTRJS'TTRJS'TRFTRJS 'TRMS!UR:RN5 UU4S"jnTRMS#U5 TRQS$URST55 U4S%jnTRUS&U5 TRQS'URV5 [0R2"T5Ul,[ZR\"UTT5 UR_5bVURmUR`RS(5(dTRcS)S5 U4S*jnTReS+U5 T$),Nr7r�r�stransaction requires locking)r��journalsabandoned transaction founds(run 'hg recover' to clean up transactionr�z/cannot open a transaction with a dirty dirstates%.40f#%fsTXN:s
pretxnopenT)r��txnname�txnidc��grGr[)�xs rTr��-localrepository.transaction.<locals>.<lambda>�	s��drZr!shook-track-tags�stripc��>�T"5nUce[R"URUT5nURR	5n[R"URX5n[R
"URXU5nU(a@SURS'URSSSS9n[R"Xe5 SSS5 gg!,(df   g=f)N�1s	tag_movedschanges/tags.changes�wT)�
atomictemp)	r��	fnoderevsrr�headrevs�difftags�hookargsr7�	writediff)	�tr2rP�	oldfnodes�newheads�	newfnodes�changes�changesfile�oldheads�reporefs	       ��rT�	tracktags�.localrepository.transaction.<locals>.tracktags�	s�����y���'�'�'�#�-�-�d�g�g�t�X�F�	��>�>�2�2�4��#�-�-�d�g�g�t�F�	�"�*�*�4�7�7�D�Y�O���15�C�L�L��.����/��$�"��$� �)�)�+�?�
�����s�4C�
C#c	��>�T"U5 T"5nUceSnURR"U6nU(abURR"U6SnURSS5nURSS5(aSnOSn[R
"XTXV5 [R"URS	5(a�[TRS
R55Hqunup�TRR5n
U
R[R"XxU	55 UR"SSS0[ R""U
5D6 Ms [R"URS
5(a�UR%5R&nTRSH�unup�UH�n
TRR5n
[)UR+U
55nU
R[,R"X�U	55 UR"SSS0[ R""U
5D6 M� M� UR"SSS0[ R""TR5D6 g)zwill run pre-closing hooksN)r!ssingle-head-per-branchrsaccount-closed-headsFspublic-changes-onlys	immutabler�pretxnclose-bookmarkrr�T�pretxnclose-phaser	)r�)r�)spretxnclose)rr��configsuboptionsr�r/�enforcesingleheadr�hashookr�ryr�rsrr�r�preparehookargsr)r�rHrr
rCr&)rurP�
singleheadopt�
singlehead�
singleheadsub�
accountclosedr�r�rSrTr�rur�r?rC�descr|rbr}s               ����rT�validate�-localrepository.transaction.<locals>.validate�	s!���$
�c�N��9�D��#�#�#�H�M����+�+�]�;�J�� $��� 8� 8�-� H�� K�
� -� 1� 1�+�U�!�
�!�$�$�%;�U�C�C�!-�J�!+�J��)�)��t�]���|�|�D�G�G�%<�=�=�(.��J�J�|�,�2�2�4�)�$�D�*�3��;�;�+�+�-�D��K�K�	� 9� 9�$�S� I�J��I�I�/��"��#�,�,�T�2��)��|�|�D�G�G�%9�:�:��_�_�&�0�0��(*�
�
�9�(=�$�D�*�3�#��!�{�{�/�/�1��"�2�7�7�3�<�0�����F�$:�$:�4�c�$J�K��	�	�0��"&��'�0�0��6��	 $�)>�
�I�I��
�&*�
�.6�.@�.@����.M�
rZc�>�T"5nUcgU(aURRS5 gURSS9 grb)rr�rB)rb�successrPr|s   �rT�	releasefn�.localrepository.transaction.<locals>.releasefn+
s;����9�D��|�
���
�
�#�#�D�)����t��4rZ�undoc��grGr[r[rZrTr�rjE
s��DrZ)�	validatorr��checkambigfilesr��origrepolens
obsmarkersr	rstxnidstxnnameschangess
flush-fncachec�j>^�URmUUU4SjnT"5nUceURU5 g)z@To be run if transaction is successful, will schedule a hook runc	��>�T
"5nUce[R"URS5(a�[TRSR55nUHqunupETRR5nUR[R"X4U55 UR"S	SS0[R"U5D6 Ms [R"URS5(a�UR5Rn[TRSSS9nUH�un	upEU	H�n
TRR5n[UR!U
55nUR["R"X�U55 UR"S
SS0[R"U5D6 M� M� UR"SSS0[R"T5D6 g)N�txnclose-bookmarkrr�F�txnclose-phaser	c��USS$)Nrr[)rrs rTr��Ulocalrepository.transaction.<locals>.txnclosehook.<locals>.hookfunc.<locals>.<lambda>u
s��Q�q�T�!�WrZ)rP)r�)r�)stxnclose)rr�rr�ryr�rsrr�rr�r)r�rHrr
rCr&)�unused_successrP�	bmchangesr�rSrTr�ru�phasemvr�r?rCrsr|rbs            ���rT�hookfunc�Clocalrepository.transaction.<locals>.txnclosehook.<locals>.hookfuncc
s�����y���'�'�'��<�<����)=�>�>� &�r�z�z�,�'?�'E�'E�'G� H�I�,5�(��j�s�!�{�{�/�/�1�����I�$=�$=�d��$M�N��	�	�0��"'��'�0�0��6��-6��<�<����):�;�;����*�4�4�B�$��
�
�9�-�3D��G�-4�(��j�s�#'�C�#%�;�;�#3�#3�#5�D�#&�r�w�w�s�|�#4�D� �K�K��(>�(>�t�#�(N�O� �I�I� 1��&+��#+�"4�"4�T�":��	$(�-4��	�	���',��08�0B�0B�8�0L�rZN)rs�
_afterlock)rur�rPrsr|rbs   @��rT�txnclosehook�1localrepository.transaction.<locals>.txnclosehook[
s5����|�|�H�!
�F�9�D��#�#�#��O�O�H�%rZs
txnclose-hooks-warm-cachec�>�T"5nUceUR"SSS0[R"UR5D6 g)z#To be run if transaction is abortedNr�F)stxnabort)rr)r�rs)rurPr|s  �rT�txnaborthook�1localrepository.transaction.<locals>.txnaborthook�
sD����9�D��#�#�#��I�I��
�#(�
�,4�,>�,>�s�|�|�,L�
rZs
txnabort-hooksrefresh-filecachestatssbranchr4c�V>�TR5HnURUSSS9 M g)NTrh)�hardlinkr�)�all_file_names�	addbackup)rbr��dss  �rT�backup_dirstate�4localrepository.transaction.<locals>.backup_dirstate�
s*����*�*�,�A��L�L��T�H�L�E�	-rZsdirstate-backup)3rr�r�r�rr�r��nestr�r�r�rr�_dirty�random�timer
r<�sha1�digestr�
_writejournalr]r�r�r�rrqr4r1r�rk�
_journalfiles�add_journalr�ryrWrs�addfinalizer��addpostclose�_buildcacheupdater�addabort�_refreshfilecachestatsr�r/�registersummarycallback�currentwlockr7�	setbranch�addvalidator)rOr��reportr��idbase�harg�rp�vfsmap�shouldtracktagsr�r��vfs_idror�r�r�r�r{r|rbr}s `               @@@@@rTr4�localrepository.transaction�	s�����7�7���h��8�8�D�G�G�<N�<N��n�=
�=
�� � ����/�7��,�,�-L�M�M�
�
$�
$�
&��
�>��7�7��7�%�%��9�9���J�'�'��/�/��0�1��B�C��
� �=�=���A�A��(�(��+�+���
�
������=�=��
����v�&�-�-�/�
0���"����	�	�-�t�T��	�G����4� ���B������B������+�+�d�#��D#�	��'�'�,�,��/�
���8����~�~�.�.�0�H�
@�&>	�>	�@	5�(�
$�
$���I�I������J�J�!�!���(��
��!�.�.�0�L�F��N�N�6�(�1�%(��Y��
�
�>�"�$'�E��
�
�=�!� "��
�
�9��#%��
�
�<� � %����H��"&����J��"$�*�*����J��	���'����)9�)9�:�-	&�^	���'��6�
	�����(?�(?��(C�D�	�	���$�l�3�	���1�4�3N�3N�O� ���R�����'�'��b�$�7� ����*����B��8�8�?�?�9�-�-����Z��.�
F�
�O�O�.��@��	rZc�:�URS4URS44$)Nre�journal.descr�r�s rTr��localrepository._journalfiles�
s$��
�Y�Y�
�#�
�X�X��'�
�	
rZc�n�UR5VVs/sHupU[U54PM snn$s snnfrG)r��undoname)rOr7ris   rT�	undofiles�localrepository.undofiles�
s0��15�1C�1C�1E�F�1E�v�s��h�q�k�"�1E�F�F��Fs�1c�X�URRSS[U5U4-5 g)Nr�s%d
%s
)r7r�r�)rOr�s  rTr��localrepository._writejournal�
s"���������s�4�y�$�6G�(G�HrZc	���UR5 URRS5(a�URR	[S55 URn[R"URUSURR[S9 UR5 SSS5 gURR[S55 SSS5 g!,(df   g=f)Nres%rolling back interrupted transaction
)r�Ts%no interrupted transaction available
F)rr�r�r�statusrr�r4�rollbackr]rkrB)rOr�s  rT�recover�localrepository.recover�
s���
�Y�Y�[��y�y���
�+�+������q�!J�K�L������$�$��I�I����G�G�L�L�$0�����!���[������Q�H�I�J���[�[�s�BC$�6%C$�$
C2c�D�S=p4UR5nUR5nURRS5(aUR	X5[XC5 $URR[S55 [XC5 g![XC5 f=f)Nr�s"no rollback information available
r)	�wlockrr�r��	_rollback�releaserr]r)rO�dryrun�forcer�rs     rTr��localrepository.rollback�
s|�����		!��J�J�L�E��9�9�;�D��y�y����(�(��~�~�f�4�

�D� ������Q�E�F�G���D� ��G�D� �s�AB�!$B�
Bc	�^^^�TRnTRR5nTRR	S5R5n[
US5USSp�n[U5S:�aUSnUS-
mU(a"UR(a[S5TXx4-n	O[S5TU4-n	[UU4SjU55n
U(d9TSTS:wa-US
:Xa'[R"[S5[S5S9eURU	5 U(agTR5 TR nSnU
(d["n[$R&"TR(USUR*[,US9 TR/5 TRR/5 U
(GaTTR0R2R4m[7U4SjTRR855(dcTRR;T5 TRR=TR>5 TRRA5 SSS5 [CTSR5V
s/sHo�RE5PM sn
5n[U5S:�aUR[S5U-5 OUR[S5U-5 [FRHRKT5 TRM5 g![a [S	5n	SnS
n
GNhf=f!,(df   N�=fs sn
f)Ns	undo.descrrr�r1s8repository tip rolled back to revision %d (undo %s: %s)
s4repository tip rolled back to revision %d (undo %s)
c3�P># �UHnTUR5T:�v� M g7frG)r?)r��p�oldtiprOs  ��rTr��,localrepository._rollback.<locals>.<genexpr>�
s ����E�W��T�!�W�[�[�]�V�3�W�s�#&s!rolling back unknown transaction
Trnr��commits;rollback of last commit while not checked out may lose datasuse -f to forcer�r�)r��skip_journal_patternc3�4># �UH
nT"U5v� M g7frGr[)r�r��has_nodes  �rTr�r�%s����>�,=�q�x��{�{�,=�s�s3working directory now based on revisions %d and %d
s+working directory now based on revision %d
)'rrror7r��
splitlinesr�r��verboserr�r�rrWr��
destroyingr��RE_SKIP_DIRSTATE_ROLLBACKr4r�r�r]rkrBrrpr��all�_pl�changing_parentsrr��clearr�r?�
mergestatemodr �clean�	destroyed)rOr�r�rror��oldlenr��detailru�
parentgoner�r�r�r�r�s`             @@rTr��localrepository._rollback�
s����
�W�W���-�-�'�'�)��	��8�8�=�=��.�9�9�;�D�&)�$�q�'�l�D��G�T�6�V��4�y�A�~��a����a�Z�F��"�*�*��(���T�*�+��
�L���T�N�#���E�W�E�E�J���d��t�F�|�3��	�8I��+�+��%���)�*��
�	�	�	�#������������#���#<� �����I�I����G�G�(�!5�
	
�	
�����
�
� � �"���~�~�+�+�4�4�H��>�D�M�M�,=�,=�>�>�>��]�]�3�3�D�9��M�M�,�,�T�[�[�9��M�M�'�'�)�:��d�4�j�.@�.@�.B�C�.B��U�U�W�.B�C�D�G��7�|�a���	�	��1���	���	�	��E�F��P��
�$�$�*�*�4�0�
	
�������	��9�:�C��D��J�	��P:�9��Ds%�B%L� AL<�M
�L9�8L9�<
M
c�@^�[R"U5mU4SjnU$)z�called during transaction to build the callback updating cache

Lives on the repository to help extension who might want to augment
this logic. For this purpose, the created transaction is passed to the
method.
c�@>�T"5nUceURU5 grG)�updatecaches)rbrPr|s  �rT�updater�3localrepository._buildcacheupdater.<locals>.updaterKs$����9�D��#�#�#����b�!rZr�)rO�newtransactionr�r|s   @rTr��"localrepository._buildcacheupdaterAs����+�+�d�#��	"�
�rZc���Ub URRS5S:XagUR5nUc[Rn[R
U;a�UbURS[U5:a�URRS5 [RU;nURS5nURRXeS9 URS5nURRXuS9 [RU;aURR!US	9 [R"U;a�UR$R!US	9 UR&R)5H\nUR*(dMUR,(dM)UR/U5R15n	U	cMMU	R!US	9 M^ [R2U;aDUR55n
URHnU
R7U5 M U
R95 [R:U;a*US
R=5HnUR?5 M [R@U;a[BRD"U5 [RFU;aURI5 [RJU;aURS5RI5 [RLU;ab[RU;n[NRPRS5H-n
URU
5nURRX�S9 M/ URRUU5 g)arwarm appropriate caches

If this function is called after a transaction closed. The transaction
will be available in the 'tr' argument. This can be used to selectively
update caches relevant to the changes in that transaction.

If 'full' is set, make sure all caches the function knows about have
up-to-date data. Even the ones usually loaded more lazily.

The `full` argument can take a special "post-clone" value. In this case
the cache warming is made after a clone and of the slower cache might
be skipped, namely the `.fnodetags` one. This argument is 5.8 specific
as we plan for a cleaner way to deal with this for 5.9.
Nssourcerkr�supdating the branch cache
r�)�detect_pure_topor�)r4rn)+rsr�rHr;�CACHES_DEFAULT�CACHE_BRANCHMAP_SERVEDryr�rr=� CACHE_BRANCHMAP_DETECT_PURE_TOPOrr��update_disk�CACHE_CHANGELOG_CACHEr�
update_caches�CACHE_MANIFESTLOG_CACHEr+r1�walk�	is_revlog�is_manifestlog�get_revlog_instance�
get_revlog�CACHE_REV_BRANCHr��
branchinfor��CACHE_FULL_MANIFESTro�manifest�CACHE_FILE_NODE_TAGSr��
warm_cache�CACHE_TAGS_DEFAULTr3�CACHE_TAGS_SERVED�CACHE_BRANCHMAP_ALLr*�filtertable�keys�write_dirty)rOrb�full�cachesrR�dpt�served�
served_hidden�entry�manifestrevlog�rbcrrr�filtrs               rTr��localrepository.updatecachesRs��� �>�b�k�k�o�o�i�8�H�D�
���� ���>��.�.�F��,�,��6��z�R�Z�Z��7�#�d�)�C����
�
�<�=� �A�A�V�K�����y�1���"�"�.�.�v�.�L� $�
�
�.>� ?�
��"�"�.�.�!�/���+�+�v�5��N�N�(�(�R�(�8��-�-��7����*�*�r�*�:������*�������+�+��!&�!:�!:�4�!@�!K�!K�!M��!�-�"�0�0�R�0�@�+��&�&�&�0��%�%�'�C��^�^�����q�!�$��I�I�K��)�)�V�3��D�z�)�)�+������,��*�*�f�4����t�$��(�(�F�2��I�I�K��'�'�6�1��M�M�)�$�)�)�+��)�)�V�3��=�=��G�C� �,�,�1�1�3���=�=��.���"�"�.�.�x�.�N�4�
	
���&�&�t�,rZc���S[U5;a
URS	URR5 UR	5 UR
R5 g)Nr�)r�rIr�r��invalidatevolatilesetsr�r�s rT�invalidatecaches� localrepository.invalidatecaches�sJ���4��:�%��
�
�l�+���� � �"��#�#�%��"�"�(�(�*rZc��URR5 [R"U5 UR	5 grG)r�r�r$�clearobscachesr{r�s rTr!�&localrepository.invalidatevolatilesets�s.�����#�#�%�����%��.�.�0rZc��UR5nSUR;a+URR(aeURS	gg)aiInvalidates the dirstate, causing the next call to dirstate
to check if it was modified since the last time it was read,
rereading it if it has.

This is different to dirstate.invalidate() that it doesn't always
rereads the dirstate. Use dirstate.invalidate() if you want to
explicitly read the dirstate again (i.e. restoring it to a previous
known good state).rN)rHrIr�is_changing_anyr�s  rT�invalidatedirstate�"localrepository.invalidatedirstate�s@����� ������&��}�}�4�4�4�4��
�
�j�)�'rZc���UR5n[URR55HpnUS:Xa2UR	5(aUR
R(aM;U(a
URU	[U[R"U55 Mr UR5 UR	5(dURR5 gg![a M�f=f)aInvalidates both store and non-store parts other than dirstate

If a transaction is running, invalidation of store is omitted,
because discarding in-memory changes might cause inconsistency
(e.g. incomplete fncache causes unintentional failure, but
redundant one doesn't).
r$N)
rH�listr�rr�r�is_delaying�delattrr)r��AttributeErrorr"r1)rOrcrHr�s    rTrB�localrepository.invalidate�s����_�_�&�
��d�o�o�*�*�,�-�A��\�!��+�+�-�-��N�N�.�.�
���O�O�A�&�
�
�
�H�O�O�A�$6�7�%.�*	
�����&�&�(�(�
�J�J�'�'�)�	)��"�
��
�s� C)�)
C7�6C7c�D�UR5 UR5 g)zqFully invalidates both store and non-store parts, causing the
subsequent operation to reread any outside changes.N)rBr)r�s rT�
invalidateall�localrepository.invalidateall�s��	
�������!rZc���URR5HBup#[R"U5nUS:XdX R;aM2UR5 MD g)z>Reload stats of cached files so that they are flagged as validrN)r�r�r)r�rIr/)rOrbr��ces    rTr��&localrepository._refreshfilecachestats�sG���_�_�*�*�,�E�A�����"�A��J��!�=�=�"8���J�J�L�	-rZc
��SnSn	U(a8URRSS5nURRSS5n	URRSS5n
URRSS5nU(dSnUc)[R
"URUUUU	UUUU
US9
nU$[R"URUUUUUUU
S	9nU$)
Nr�uistimeoutstimeout.warnssignal-safe-lockr7slock-wait-sync-file)r��	acquirefnr��
signalsafe�devel_wait_sync_file)r�r9r�r:)rr#r�r��lockmod�trylock�
steal_lock)
rOr7�lockname�waitr�r9r��
steal_from�timeout�warntimeoutr:�	sync_filer�s
             rT�_lock�localrepository._lock�s���������g�g�'�'��z�:�G��'�'�+�+�E�?�C�K��W�W�'�'��/B�C�
��G�G�N�N�8�-C�D�	���I�������������#�#��%�%.��A�0���"�"�������#�#��%�	�A��rZc���URUR4HJnU=(a U"5nU(dMUR(dM/URR	U5  g U"S5 g)z�add a callback to be run when the repository is fully unlocked

The callback will be executed when the outermost lock is released
(with wlock being higher level than 'lock').TN)r�r��held�postreleaser�)rOr�r�r�s    rTr��localrepository._afterlock*sQ��
�N�N�D�M�M�2�C��
���A��q�Q�V�V�V��
�
�$�$�X�.��	3�
�T�NrZc
�v�URUR5nUb-UbSn[R"U5eUR	5 U$UcURSSS9 UR
URSUSUR[S5UR-US9n[R"U5UlU$)	a�Lock the repository store (.hg/store) and return a weak reference
to the lock. Use this before modifying the store (e.g. committing or
stripping). If you are opening a transaction, get a lock as well.)

If both 'lock' and 'wlock' must be acquired, ensure you always acquires
'wlock' first to avoid a dead-lock hazard.


The steal_from argument is  used during local clone when reloading a
repository. If we could remove the need for this during copy clone, we
could remove this function.
Nz#cannot steal lock if already lockedsprelockT�r�slocks
repository %s�r7r?r@r�r9r�rA)
r�r�rr�rrrEr�rBrr�r�r�)rOr@rAr�rus     rTr�localrepository.lock7s���
���d�m�m�,���=��%�;���,�,�S�1�1�
�F�F�H��H����I�I�j��I�-��J�J��	�	�����o�o��#�$�t�}�}�4�!�
�
�� ���A���
��rZc
�^�TRTR5nUb-UbSn[R"U5eUR	5 U$UcTRSSS9 U(ayTRRSS5(d!TRRSS5(a7TRTR5bTRRS5 U4S	jnTRTRS
UUTR[S5TR-US9n[R "U5TlU$)
a�Lock the non-store parts of the repository (everything under
.hg except .hg/store) and return a weak reference to the lock.

Use this before modifying files in .hg.

If both 'lock' and 'wlock' must be acquired, ensure you always acquires
'wlock' first to avoid a dead-lock hazard.

The steal_from argument is  used during local clone when reloading a
repository. If we could remove the need for this during copy clone, we
could remove this function.
z$cannot steal wlock if already lockedsprewlockTrLr7r�r�s"wlock" acquired after "lock"c�>�TRR(a8SnTRRU5 TRR	5 OSTRR
(aSnTRRU5 TRR
S5 TR5nSUR;aURS	gg)Ns1wlock release in the middle of a changing parentssdirty dirstate on wlock releaser)	rr(rr�rBr�r�rHrI)rurRrOs  �rT�unlock�%localrepository.wlock.<locals>.unlockzs�����}�}�,�,�J�����!�!�#�&��
�
�(�(�*��=�=�'�'�<�C��G�G�%�%�c�*��
�
�#�#�D�)��?�?�$�D��T�]�]�*��M�M�*�-�+rZswlocksworking directory of %srM)r�r�rr�rrrr�r�r�rEr7r)rr�r�r�)rOr@rAr�rurQs`     rTr��localrepository.wlockZs���
���d�n�n�-���=��%�<���,�,�S�1�1�
�F�F�H��H����I�I�k��I�.���G�G���x��9�9��w�w�!�!�(�N�;�;�� � ����/�;����!�!�"B�C�
	.�
�J�J��������-�-��-�.����>�!�
�
��!���Q�����rZc�F�UcgU"5nUbUR(dgU$)�3Returns the lock if it's held, or None if it's not.N)rH)rO�lockrefr�s   rTr��localrepository._currentlock�s$���?���I���9�A�F�F���rZc�8�URUR5$)z4Returns the wlock if it's held, or None if it's not.)r�r�r�s rTr��localrepository.currentwlock�s��� � ����0�0rZc�8�URUR5$)rU)r�r�r�s rTrA�localrepository.currentlock�s��� � ����/�/rZc���UR5(dUR5(GaA[URUR-UR
-5nUR
5H�nURRU5nUS:XdXe;dXaR;aM:XcR;aU"U[S55 URRU5(d$UR5RU5(a;US-nUHnUR!U5(dM M� U"U[S55 M�X`R;dM�U"U[S55 M� gg)z2check for commit arguments that aren't committablernsfile not found!rsno match under directory!sfile not tracked!N)�isexactrsrW�modified�added�removedrYr�	normalizer��deletedrr�r�rs�hasdirrU)	rO�wctxrr��fail�matchedr��dr6s	         rT�checkcommitpatterns�#localrepository.checkcommitpatterns�s���=�=�?�?�e�l�l�n�n��&�/�/�F�L�L�8�6�>�>�I�J�G��[�[�]���M�M�+�+�A�.����9����]�]�0B�����&���A�0�1�2��9�9�?�?�1�%�%�����)9�)9�!�)<�)<��D��A�%���=�=��+�+�!�&��Q��">� ?�@��m�m�+���A�2�3�4�#�-rZc�h	^^^^�Uc0nSnU(d[R"5nU(dX�lTR5 TR	5 TSn	[U	R
55S:�n
U(d;U
(a4UR5(d[R"[S55eTRXES9nU(a%URRUR5 [R"TR X�XES9up�nU(dTR#X�X�5 [$R&"TX�X#U5n[(R*R-T5n[.R0"U5 UR35(a^TR R5SS5(d=TR R7S	5 UR95 SSS5 SSS5 gU
(a4UR;5(a[R"[S
55eU(aU"TX�5UlXR<:gnTR?UR<5nU(a�[@RB"T5n[EU
5H~nU	RGU5nTR R[S5U"[RH"U55-5 URKUR<X#5nUUSU4UU'M� [RL"TU5 TRNR
5unn[QU5UTRR:g=(a [QU5=(d S
smmTRUSSTTS9 TRWS5 TRYUS5m[ZR\"TUU/T5 UR_T5 UR95 SSS5 SSS5 SSS5 UUUU4SjnTRcU5 T$!,(df   N:=f! U(aNTR Ra[S5U-5 TR Ra[S5U-5 e=f!,(df   N�=f!,(df   N�=f)z�Add a new revision to current repository.

Revision information is gathered from the working directory,
match can be used to filter the committed files. If editor is
supplied, it is called to get a commit message.
Nc�6�[R"SX4-5e)Ns%s: %s)r�
InputError)r�rus  rTre�$localrepository.commit.<locals>.fail�s���"�"�9��x�#7�8�8rZrsBcannot partially commit a merge (do not specify files or patterns))rr�)r�r8sallowemptycommits(nothing to commit, clearing merge state
s&cannot commit merge with missing filesscommitting subrepository %s
rrZs	precommitT)r��parent1�parent2r�s!note: commit message saved in %s
s6note: use 'hg commit --logfile %s --edit' to reuse it
c�~>�TRRT5(aTRS[T5TTS9 gg)Nr�)rCrnro)r�hasnoderr
)r��hookp1�hookp2rgrOs ����rT�
commithook�*localrepository.commit.<locals>.commithook7
s=����~�~�%�%�c�*�*��	�	��C��H�f�f���+rZ)2rOrP�badr�rr�rorrWrr�r^�extendr�r2�	precommitrrhr�workingcommitctxr�r r�r!�checkunresolved�isemptyr�r=�resetrb�_text�savecommitmessager/�getuipathfnr�r��
subrelpathr�
writestaterr
r�rr4�	commitctxrr��
markcommittedr�r�)rO�textr��daterr��editor�extrarerd�merger��subs�
commitsubs�newstate�cctx�ms�edited�msg_path�uipathfnr+r��srrsrrtrrrsrgs`                         @@@rTr�localrepository.commit�s����"�=��E�	9���O�O�%�E���I��Z�Z�\�4�9�9�;���:�D������'�!�+�E��U�5�<�<�>�>��k�k��>�����[�[�u�[�:�F�����&�&��L�L��
*5�)>�)>�����u�*�&�D�h�
��(�(��f�C��+�+��f�D���D��)�)�.�.�t�4�B��%�%�b�)��|�|�~�~�d�g�g�&8�&8��*�'�'����
�
�J�K����
��Q'�\�\�T�������k�k�!�$M�"N�O�O��#�D�$�5��
��Z�Z�'�F�
�-�-�d�j�j�9�H��"�.�.�t�4���
�+�A��(�(�1�+�C��G�G�N�N��:�;�"�;�#9�#9�#�#>�?�@�����D�J�J��;�B�#+�A�;�q�>�2�"6�H�Q�K�,��&�&�t�X�6��]�]�*�*�,�F�B�� ��W�r�T�[�[�'8�'D�S��W�'K��N�F�F�
��	�	� ��f�f����%�%�i�0��.�.��t�4�C��$�$�T�B��8�S�9��&�&�s�+��H�H�J�1�S'�\�z	�	�	
���
�#��
�;1�0��
���G�G�M�M��?�@�8�K���G�G�M�M��8��#�	#����w'�;��\�\�sj�R#�FR�"R#�3F
R�#P7�$AP&�2P7�:R#�&
P4�0P7�3R�4P7�7AR�R�
R 	�R#�#
R1c�,�[R"XX#S9$)N)r�origctx)rr�)rOrrr�s    rTr��localrepository.commitctxB
s�������H�HrZc�Z�S[U5;aURRU5 gg)a�Inform the repository that nodes are about to be destroyed.
Intended for use by strip and rollback, so there's a common
place for anything that has to be done before destroying history.

This is mostly useful for saving state that is in memory and waiting
to be flushed when the current lock is released. Because a call to
destroyed is imminent, the repo will be invalidated causing those
changes to stay in memory (waiting for the next unlock), or vanish
completely.
rN)r�rr�r�s rTr��localrepository.destroyingF
s)���D��J�&����"�"�4�(�'rZc�D�UR5 UR5 g)z�Inform the repository that nodes have been destroyed.
Intended for use by strip and rollback, so there's a common
place for anything that has to be done after destroying history.
N)r�rBr�s rTr��localrepository.destroyedX
s��	
����	
���rZc�,�XRX#XEXg5$)z3a convenience method that calls node1.status(node2))r�)rO�node1�node2r�ignoredr��unknown�listsubreposs        rTr��localrepository.statusm
s ���{�!�!��'�'�
�	
rZc�:�URRU5 g)a�Add a callback to run within the wlock, at the point at which status
fixups happen.

On status completion, callback(wctx, status) will be called with the
wlock held, unless the dirstate has changed from underneath or the wlock
couldn't be grabbed.

Callbacks should not capture and use a cached copy of the dirstate --
it might change in the meanwhile. Instead, they should access the
dirstate via wctx.repo().dirstate.

This list is emptied out after each status run -- extensions should
make sure it adds to this list each time dirstate.status is called.
Extensions should also make sure they don't call this for statuses
that don't involve the dirstate.
N)r�r�)rO�pss  rT�addpostdsstatus�localrepository.addpostdsstatus|
s��(	
���!�!�"�%rZc��UR$)zAUsed by workingctx to get the list of post-dirstate-status hooks.�r�r�s rT�postdsstatus�localrepository.postdsstatus�
s���!�!�!rZc�"�URSS2	g)z7Used by workingctx to clear post-dirstate-status hooks.Nr�r�s rT�clearpostdsstatus�!localrepository.clearpostdsstatus�
s�����q�!rZc��UcFURn[UR55nUVs/sHoBRU5PM sn$URR	U5n[XPRRSS9$s snf)NT)rP�reverse)r�reversedrqrCr4r�r?)rO�startrurqr?r4s      rTr4�localrepository.heads�
sk���=����B�����
�.�H�,4�5�H�S�G�G�C�L�H�5�5����$�$�U�+���e���!3�!3�T�B�B��	6s�Bc	�X�UcUSR5nUR5nURU5(d/$[[	URXS955nUbB[
URRU/U5S5nUVs/sHowU;dM
UPM nnU$s snf)a.return a (possibly filtered) list of heads for the given branch

Heads are returned in topological order, from newest to oldest.
If branch is None, use the dirstate branch.
If start is not None, return only heads reachable from start.
If closed is True, return heads that are marked as closed as well.
N)�closedr1)	r�rrr,r��branchheadsrWr�nodesbetween)rOr�r�r�r�bheads�fbheads�hs        rTr��localrepository.branchheads�
s����>��$�Z�&�&�(�F��>�>�#���!�!�&�)�)��I��h�x�3�3�F�3�J�K�L�����$�.�.�5�5�u�g�v�F�q�I�J�G�!'�8��A��<�a��F�8��
��9s�	B'�B'c�*�U(dURR5/n/nUHhnUnURRU5nUSUR:wdUSUR:XaUR	XCUSUS45 McUSnMd U$)Nrr)rr�ror�r�)rOrGrmr�r�r�s      rTr�localrepository.branches�
s�����^�^�'�'�)�*�E����A��A���N�N�*�*�1�-���Q�4�4�;�;�&�!�A�$�$�+�+�*=��H�H�a�A�a�D�!�A�$�/�0���a�D�����rZc�$�/nUH�up4U/SpvnSnXT:waeXPR:waVURRU5Sn	Xx:XaURU5 US-nU	nUS-
nXT:waXPR:waMVURU5 M� U$)Nrrr1)r�rror�)
rOr|rr�top�bottomr�r�r�r�r�s
          rTr{�localrepository.between�
s����� �K�C��2�q�!�A��A��+�!�{�{�"2��N�N�*�*�1�-�a�0���6��H�H�Q�K��A��A����Q���
�+�!�{�{�"2�
�H�H�Q�K�!��rZc��g)z�Extensions can override this function if additional checks have
to be performed before pushing, or call it if they override push
command.
Nr[)rO�pushops  rT�	checkpush�localrepository.checkpush�
s�rZc�,�[R"5$)zxReturn util.hooks consists of a pushop with repo, remote, outgoing
methods, which are called before pushing changesets.
)r6�hooksr�s rT�prepushoutgoinghooks�$localrepository.prepushoutgoinghooks�
s��
�z�z�|�rZc�^^^^^^	�TR5n0nUbURUR5 [R"U5nTUS'TUS'TUS'TUS'TR
"SSS0UD6 TRRS
TT4-5 [R"TTTTT5m	UUUUU	U4SjnTRU5 T	$![RasnTRR[S5U-5 UR(a1TRR[S5UR-5 SnAg	SnAff=f)
NrKrPrSrTr�Tspushkey-abort: %s
s(%s)
Fspushing key for "%s:%s"
c	�.>�TRSTTTTTS9 g)Nr�)rKrPrSrTrg)r)r�rPrKrTrSrgrOs ������rT�runhook�(localrepository.pushkey.<locals>.runhook�
s&����I�I��#�����

�
rZ)s
prepushkey)r�r�rsr)r�rr�	HookAbortr�	write_errrr�r=r(�pushr�)
rOrKrPrSrTrbrsrir�rgs
`````    @rTr(�localrepository.pushkey�
s%���	��(�(�*�B��H��~�������,��)�)�(�3�H�$-�H�[�!�!�H�U�O�!�H�U�O�!�H�U�O��I�I�<�4�<�8�<�	
���
�
�2�i��5E�E�F��l�l�4��C��c�:��	�	�	
���� ��
��'���	��G�G���a� 6�7�#�=�>��x�x����!�!�!�I�,����"9�:���		�s�A.C�E�"A)E�Ec��URSSUS9 URRSU-5 [R"X5nURSXS9 U$)NsprelistkeysT)r�rKslisting keys for "%s"
slistkeys)rKr�)rrr=r(r,)rOrKr�s   rTrJ�localrepository.listkeyssM���	�	�.��	�	�B����
�
�0�9�<�=����d�.���	�	�+��	�B��
rZc��SUU[R"U5[R"U5[R"U54-$)z+used to test argument passing over the wirer'r(r*s      rTr0�localrepository.debugwireargsr2rZc��URSS5nURU5 UR5 URUR[UR5S-S5$!UR5 f=f)Nslast-message.txtswbr)r7r�r�r$r�r�r�)rOr��fps   rTr~�!localrepository.savecommitmessagesa��
�X�X�)�5�
1��	��H�H�T�N��H�H�J��{�{�2�7�7�3�t�y�y�>�A�#5�#7�8�9�9��
�H�H�J�s�A)�)A;c��[RUR;agURR	[
R"U55 grG)r;r�r�rrlr)r))rO�categorys  rT�register_wanted_sidedata�(localrepository.register_wanted_sidedata!s6���,�,�D�M�M�A�����!�!�(�"2�"2�8�"<�=rZc��U[R;a#[S5n[R"Xq-5e[
R"U5nX RRU/5;nU(a*U(d#[S5n[R"Xr-5eU(a*U(d#[S5n[R"Xr-5eURRU05 X4U4URUU'g)Nsunexpected revlog kind '%s'.s<cannot register a sidedata computer twice for category '%s'.sKcannot replace a sidedata computer that isn't registered for category '%s'.)
rR�	ALL_KINDSrrr�r)r)r�r�r�)	rO�kindr�r�computerrZ�replaceru�already_registereds	         rT�register_sidedata_computer�*localrepository.register_sidedata_computer's����{�,�,�,��3�4�C��(�(���4�4��#�#�H�-��%�)A�)A�)E�)E�d�B�)O�O���g��O��C��(�(���8�8��-��&��C��(�(���8�8�� � �+�+�D�"�5�48�E�3J�� � ��&�x�0rZ)*r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�r�ror+r�r�r~r�r1rr�rr7r�r�rG)r��bytesr��
vfsmod.vfsr�r�r�r�r�r�r�r�r�)r�r�)FN)r�r�)rsr�)F)r�r�rr�rsr�rt�ror�)r�r�r%zOptional[bytes]rsr�)r<r�rsr�)r<r�r@r�rZr�rsr�)r<r�r@r�rsr�)FF)NFN)TN)rZNNNFNN)rnNNFFFFrr)�r\r]r^r_r`r��ARCHIVED_PHASE_REQUIREMENT�BOOKMARKS_IN_STORE_REQUIREMENTr�r&r7r`rrr;�INTERNAL_PHASE_REQUIREMENTr[r�r$r�r�r�rrPrr"rr�rjr�r��propertyr�r�r�rr�r�r�r�rHrr�rrrryrr!r�rr�r+r�rr.r8r#�FILENAMErIr�rUr_rgrkrxr�r{rr�r�r��__bool__r�r�r�rWr�r
rr�r�r3r�r�r�r�r�rr�r�r�rNrrErrrr�rrrr!r$r9rArErIrLrRr[r^r�r4r�r�r�r�r�r�r�r�r"r!r)rBr2r�rEr�rr�r�r�rArhrr�r�r�r�r�r�r�r4r�rr{r�r�r(rJr0r~r�r�rar[rZrTrrs����	�2�2��6�6��/�/��-�-��0�0��/�/��-�-��+�+��0�0��2�2��+�+��3�3��,�,��,�,��*�*��-�-��*�*��0�0��)�)��0�0�)�N�2��<�]5��	]5�
�]5��
]5��]5��]5��]5�~1�f�,�
��
��)�	��K��K�
�
��
�$�L
�
�5�$� �(���	�2'�
�2'�h�
�&��&��
�/�0�<�1�<����1��1���
��
���D��D�����
�*�@�
�#�#�$�	�%�	��
�#�#�$�M�%�M��
�#�#�$�M�%�M�!�&-��
��
�����<�;��;��0��0�M,�^���H�#�
$�.� 
��2$�=�����,�"! �F	5�(�	;�+�(�
�$��$�>�� �5�	��I�
D��8�1�
�&�,�(�4
��+��+��+��+�)�D��������	�

��2D�	�z�x	
�G��I��I��$!��T��T�l�"�T-��T-�l+�1�
*�#*�J"����� �.�`�!�F9�v�1�0�5�,��
�
�����C��C�J�I��I��)��)�"����,�������

�&�,"�"�C��*��&������B�
�:�>�>C�KrZrc���[RRU5upURS5(de[RR	XRSSS55$)Nrer�r)�osrorVrUrrr�)r�r�r�s   rTr�r�>sK�������r�"�J�D��?�?�:�&�&�&�&�
�7�7�<�<��l�l�:�w��B�C�CrZc�^^^�SSKJn [R"U5mU(a[	TTUS9 UUU4SjnU"5nURXv5nU$)Nrr���
createoptsc�>�[TTTS9$)N)r�)r�)r��	localpathrs���rT�
repo_maker�instance.<locals>.repo_makerLs���"�2�y�'�B�BrZ)r�r�r?�urllocalpath�createrepository�may_auto_upgrade)	rro�creater�r�r�r�rPr�s	`  `    @rT�instancer�DsI�����$�$�T�*�I�
���Y�:�>�C��<�D��#�#�D�5�D��KrZc��gr�r[)ros rT�islocalr�Ts��rZc�d�[U=(d 05nSU;aURSS5US'U$)z�Populate the default creation options for a repository.

A dictionary of explicitly requested creation options can be passed
in. Missing keys will be populated.
�backendr/snew-repo-backend)�dictr�)rr�s  rT�defaultcreateoptsr�Xs7���j�&�B�'�J���#�!#���:�7J�!K�
�:���rZc�8�[5nUR(dU$[XS9n[X5H*nU[R
;dMUR
U5 M, URH*nU[R
;dMUR
U5 M, U$)z�clone the requirements of a local repo for a local clone

The store requirements are unchanged while the working copy requirements
depends on the configuration
r�)rWr+r��newreporequirementsr��WORKING_DIR_REQUIREMENTSrl)rr��srcrepo�target_requirementsrrs     rT�clone_requirementsrgs����%�����#�"�"�2�=�J�
 ��
0����8�8�8��#�#�A�&�1��
!�
!���O�<�<�<��#�#�A�&�"��rZc���SU;a[R"S5eUSS:wa%[R"[S5US-5e[R
1nUR
SS5(a�UR[R5 UR
SS5(aUUR[R5 UR
SS5(aUR[R5 URSS	5nUHZnU[R;dM[RUnUR5(dMCUR5(dMZ OB [R"[S
5SR!SU55-[S
5S9eUS:XaURS5 OUS:waURSU-5 ["R$"U5(aUUR[R&5 UR
SS5(aUR[R(5 UR
SS5(aUR[R*5 UR
SS5(a>UR[R,5 UR[R.5 UR
SS5(aUR[R05 UR3SS5nUS:XaUR[R,5 UR3SS5nUS:Xa>UR5[R
5 UR[R65 UR
SS5(aUR[R85 UR
SS5(aUR[R:5 UR=S5(aUR[R>5 UR=S5(aURS5 UR
SS5(aUR[R@5 [BRD"S S!S"9S#LnUR
SS$U5(aUR[RF5 UR
SS%5(aUR[RH5 S&U;a�[KUS&RL5n	[RHU	;aU	nOI[K5n
UH1nU[RN;aMX�;aM U
RU5 M3 X*-nX)-nUR=S'5(a UR[RP5 OUR[RR5 UR
SS(5(aaURUSS)5n[S*5n
[S+5nUS,:waURWX�-US9 U$UR[RX5 U$)-z�Determine the set of requirements for a new local repository.

Extensions can wrap this function to specify custom requirements for
new repositories.
r�sFbackend key not present in createopts; was defaultcreateopts() called?r+sCunable to determine repository requirements for storage backend: %srsusestores
usefncaches	dotencodesrevlog-compressionsIcompression engines %s defined by format.revlog-compression not available�, c3�,# �UH
nSU-v� M g7f)s"%s"Nr[)r�r�s  rTr��&newreporequirements.<locals>.<genexpr>�s���:�k���1��k�s�s;run "hg debuginstall" to list available compression enginesr�rsrevlog-compression-zstdszlibr�s
sparse-revlogsuse-dirstate-v2s"exp-use-copies-side-data-changesetr!rsexp-use-changelog-v2s*enable-unstable-format-and-corrupt-my-datar,suse-internal-phasesexp-archived-phase�narrowfilesr�sbookmarks-in-storer,T)�pyo3Nsuse-persistent-nodemap�use-share-safe�
sharedrepo�sharedrelativesuse-dirstate-tracked-hints!use-dirstate-tracked-hint.versions)ignoring unknown tracked key version: %d
s<see `hg help config.format.use-dirstate-tracked-hint-versionr)-rr�rWrr�r$r�rlrrr�
configlistr6rrrrrr/�gdinitconfigr;rPr`r�r&r"r�r�r�r�r�r�rYr�r'�
importrustr[r�rWr+rr�r�r#r]r7)rr�r+r�
compenginer
�changelogv2�revlogv2�persistent_nodemap_default�source_requirements�to_drop�req�versionrur�s               rTrr}sU����#��$�$�
/�
�	
�
�*���,��k�k�
�'�
���$�	
%�
�	
�$�8�8�9�L�	�}�}�Y��,�,�����:�:�;�
�=�=��M�2�2����_�@�@�A��}�}�Y��5�5�� � ��!F�!F�G��-�-�	�+@�A�K�!�
���)�)�)��%�%�j�1�F����!�!�f�&9�&9�&;�&;��	"��k�k�
�;�
��j�j�:�k�:�:�	
;�
�'��

�
	
��W�����3�4�	�w�	����.��;�<����B�������A�A�B�
�=�=��$4�5�5����_�E�E�F�
�}�}�Y� 2�3�3�����@�@�A�
�}�}�Y� E�F�F�����@�@�A�����>�>�?�	�}�}�_�o�6�6�����A�A�B��)�)�I�'>�?�K��C�C�����@�@�A��y�y��+�6�H��@�@����_�A�A�B�����=�=�>�	�}�}�Y� 5�6�6�����C�C�D�
�}�}�Y� 5�6�6�����C�C�D��~�~�n�%�%�����;�;�<��~�~�f������� �	�}�}�Y� 5�6�6�����G�G�H�	���(��.�d�:��
�}�}��,�.H���	����<�<�=�
�}�}�Y� 1�2�2�����>�>�?��
�"�!�*�]�";�"H�"H�I���0�0�8K�K�/�L��e�G�#���/�B�B�B���-�����C� �$�
�#�L��/�L��>�>�+�,�,����_�H�H�I����_�?�?�@�	�}�}�Y� <�=�=��,�,�y�*N�O���=�>���K�
���a�<��G�G�C�M��G�-���
���_�E�E�F��rZc�6�[5n[RU;a�[RU;a9UR	[S55 UR
[R5 [RU;d[RU;a[R"[S55e[RU;aRURSS5(a[S5nUR	U5 UR
[R5 U$)z�Checks compatibility of repository requirements enabled and disabled.

Returns a set of requirements which needs to be dropped because dependend
requirements are not enabled. Also warns users about itsvignoring enabled 'format.bookmarks-in-store' config beacuse it is incompatible with disabled 'format.usestore' config
s\cannot create shared repository as source was created with 'format.usestore' config disabledrrsrignoring enabled 'format.use-share-safe' config because it is incompatible with disabled 'format.usestore' config
)
rWr�rr�r]rrlr�r�rrWr�r�)rr+�droppedrus    rT�checkrequirementscompatrs����e�G��(�(��<��9�9�\�I��G�G��4��
�
�K�K��F�F�G�
�.�.�,�>��:�:�l�J��+�+��?���
��0�0�L�@��|�|�I�'8�9�9��!���
������K�K��=�=�>��NrZc�n�1SknUR5VVs0sHup4X2;dMX4_M snn$s snnf)aFilters a dict of repo creation options against options that are known.

Receives a dict of repo creation options and returns a dict of those
options that we don't know how to handle.

This function is called as part of repository creation. If the
returned dict contains any items, repository creation will not
be allowed, as it means there was a request to create a repository
with options not recognized by loaded code.

Extensions can wrap this function to filter out creation options
they know how to handle.
>r�r�rr	�shareditemsr
�shallowfilestore)r�)rr�rEr�r�s     rT�filterknowncreateoptsrCs8��
�E�(�-�-�/�B�/�T�Q�1�>�D�A�D�/�B�B��Bs�1�1c��UbUbSn[R"U5e0nO�[XS9n[X5n[	U[
5(d[R"S5eU(aB[R"[S5SR[U55-[S5S9e[XS9nU[X5-n[R"US	S	S
9n[R"URS55nUR5(a"[R"[S5U-5eS
U;aeUS
R nUR#S5(a@[$R&R)X�R*5n[,R."U5nUR5(dUR95 UR;S	S9 S
U;aUR=S5 UR=S5 [>R@U;n
U
(a)S
U;a#UR=S5 URCSS5 [DRF"U5up�[DRH"X{5 U(a@S
U;a:[R"URS5S	S9n
[DRH"X�5 S
U;aURKSW5 UR#S5(a3SR[US55S-nURKSU5 gg![0[24a7n	[R"[S5[4R6"U	5S9eSn	A	ff=f)a�Create a new repository in a vfs.

``path`` path to the new repo's working directory.
``createopts`` options for the new repository.
``requirement`` predefined set of requirements.
                (incompatible with ``createopts``)

The following keys for ``createopts`` are recognized:

backend
   The storage backend to use.
lfs
   Repository will be created with ``lfs`` requirement. The lfs extension
   will automatically be loaded when the repository is accessed.
narrowfiles
   Set up repository to support narrow file storage.
sharedrepo
   Repository object from which storage should be shared.
sharedrelative
   Boolean indicating if the path to the shared repo should be
   stored as relative. By default, the pointer to the "parent" repo
   is stored as an absolute path.
shareditems
   Set of items to share to the new repository (in addition to storage).
shallowfilestore
   Indicates that storage for files should be shallow (not all ancestor
   revisions are known).
Ns/cannot specify both createopts and requirementsr�s-filterknowncreateopts() did not return a dictsBunable to create repository because of unknown creation option: %srs#is a required extension not loaded?r�Tr�r�srepository %s already existsrr
scannot calculate relative path)�
notindexedr�r�r�r�s9�� dummy changelog to prevent using the old repo layoutr�r�rr�sshared)&rr�r�rr�r�rWrrrr�rrr�r7r�r�r�r�r�ro�relpathr�r6r�r�r�r>re�makedirs�makedir�mkdirr�rr�r/�filterrequirements�
writerequiresr�)rror�r+ru�unknownoptsr�r�r�r��	has_store�wcreq�storereqr�r�s               rTr�r�^s���<���!�D�C��(�(��-�-��
�&�r�A�
�+�B�;���+�t�,�,��(�(�@��
���+�+��+���*�*�V�K�0�1�	2�
�=�>�
�
�+�2�E���/��A�A���j�j��$��>�G��J�J�w�|�|�F�+�,�E��|�|�~�~��o�o�a� ?�@�4�G�H�H��
�"��
�.�9�9�
��>�>�+�,�,�	
��W�W�_�_�Z���D�
�!�]�]�:�6�
��>�>�������	�M�M�T�M�"��J�&�
���H��	�K�K�	���1�1�\�A�I��]�*�4�
���H��	����
�	
��0�0��>�O�E����%�'�
�M��3��:�:�e�j�j��2��F�����h�1��
�"�
���M�:�.��~�~�n�%�%����F�:�n�#=�>�?�%�G��
���I�v�&�&��e�Z�(�
��k�k��7�8�#�0�0��3����
�s�?L�M�$2M�Mc�f�UR5 "SS5n[RUSU5 g)z9Poison a repository instance so it can no longer be used.c� �\rSrSrSrSrSrg)�,poisonrepository.<locals>.poisonedrepositoryi�c�d�US:Xa[RX5$[R"S5e)Nr�s/repo instances should not be used after unshare)r��__getattribute__rr�)rO�items  rTr0�=poisonrepository.<locals>.poisonedrepository.__getattribute__�s0���w���.�.�t�:�:��(�(�B��
rZc��grGr[r�s rTr��2poisonrepository.<locals>.poisonedrepository.close�s��rZr[N)r\r]r^r_r0r�rar[rZrT�poisonedrepositoryr.�s��	�	rZr5rSN)r�r�r�)rPr5s  rT�poisonrepositoryr6�s,��	�J�J�L�
�
����t�[�*<�=rZrGr�)r�r�r�r�r�zOptional[vfsmod.vfs])r�r�rsr�)NN)ror�rs�bool)��
__future__rr�r�r��rer�r��typingr��
concurrentrrr�i18nrrCr	r
rrr
r�rrrrrrrrrrrrrrrrrr<rrOr r�r!r"r#r$r%r&r'r(r)r*r+r�r,r-r.r/r0r1rr2r3r�r4r5r6r7r�r8�	branchingr9r��
configurationr:�
interfacesr;�utilsr<r=r>r?�revlogutilsr@r'rArRrBr�r��urlerrr��compiler�rWrk�	filecacherDreryr�r�r�r��
propertycacher�r�r�r�r�unionrx�ipeercommandexecutorr�r��
ipeercommandsr��ipeerlegacycommandsrvrr�r�r�r�r�r�r�r�r�r%rz�ilocalrepositoryfilestorager|r�r��ilocalrepositorymainr�r��_localrepo_base_classes�
TYPE_CHECKINGrr�r�r�r�rrrrr�r6r[rZrT�<module>rNs���#��	�
�	�
��
����
���,�,�,�,�,�,�,�,�,�,�,�,�\�"�������/�/��	
����	
�����J�J�2����u��5�W�&�&�5�$	#�N�	#�	 ��	 ��Z���z��$�.�$�* �(�d�0�0�(�2�D�.�.�2�+�
��
��
�
�3�4�
5�
�*�:�:�:�*�ZW*�
����!9�!9�W*�xP�i��!?�!?�P�N�E���2{�F
'+�-�
�-��-�
$�-�`K�6�0
�>
�4	.�$�Nz�z�
E�
�>�>�E�

�j�D�D�

� !�"�$�$�&6�7��+�+�-D�E���
!��	�����'�'��.�.���^$K�-�^$K�BID�
� ���,X�v(�VC�6{'�|>rZ

Youez - 2016 - github.com/yon3zu
LinuXploit