ó
    Ë5žj'¾  ã            	       óJ  • % S SK r / SQr\ R                  S:X  a  \R                  S5        S SKJr  S SKrS SKJr  S SK	r	S SK
r
S SKrS SKJr  S SKJr  S SKrS SKrS SKrS SKrS SKrS SKrS SKJrJr  S SKrS S	KJrJrJrJrJrJ r J!r!J"r"J#r#  S S
K$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7  \2(       a  S SK8J9r9  S SK:J;r;J<r<  S SK=J>r>  S SK?J@r@  S SKAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJ  \4" S\5S   SS9rK\4" SSS9rL\
Rš                  " \N5      rOS\PS\QS\Q4S jrRS\PS\QS\Q4S jrS\S" SS5      rT\S" SS5      rU\4" S5      rVS\(S \V4   S\(S \V4   4S! jrW\R°                  S"\FS\*\FSS4   4S# j5       rY\R°                  S\PS$\PS\*S%   4S& j5       rZS'\FSS4S( jr[S'\FSS4S) jr\SuS*\'S+\'S,\]S\]4S- jjr^S.\FS/\FS\F4S0 jr_\ R                  S:X  a  S'\FS\P4S1 jr`S'\FS\P4S2 jra\`rbOS'\FS\P4S3 jra\arbS.\FS/\FS\F4S4 jrcS'\FS\Q4S5 jrdS6\FS'\FS\P4S7 jreSvS'\FS9\QS\Q4S: jjrfS\0\P   4S; jrgSwS<\PS'\.\F   S\-\P   4S= jjrhSxS>\.\P   S'\PS?\QS\P4S@ jjri\RÔ                  " SA5      SB S84\RÔ                  " SC5      \iS84\RÔ                  " SD5      \iS84\RÔ                  " SE\RÖ                  5      SF S4\RÔ                  " SG5      SH S844rl\1\1\/\P   \(S \P4   \Q4   S 4   \mSI'   SxS'\PS?\QS\P4SJ jjrn\RÔ                  " SK5      roS'\FS\P4SL jrp0 rq\)\P\.\Q   4   \mSM'   SN\PS\Q4SO jrr\7SNSS\ES8   4SP j5       rs\7SN\FS\Q4SQ j5       rsSN\5S\F4   S\Q4SR jrsS\P4SS jrtST\5SU   SV\%SS4SW jru\7SyS/SS?\QSS4SX jj5       rv\7SyS/\FS?\QS\.\F   4SY jj5       rvSxS/\5S\F4   S?\QS\.\F   4SZ jjrvS[\0\P   S\-\P   4S\ jrw " S] S^5      rx " S_ S`\x5      ry " Sa Sb5      rz " Sc S5      r{ " Sd Se5      r| " Sf Sg5      r} " Sh Si5      r~ " Sj Sk\~5      r " Sl Sm\-\K   5      r€\J " Sn So\G5      5       r� " Sp Sq\‚5      rƒ " Sr Ss\ƒSt9r„g)zé    N)Ústream_copyÚ	join_pathÚto_native_path_linuxÚjoin_path_nativeÚStatsÚIndexFileSHA1WriterÚIterableObjÚIterableListÚBlockingLockFileÚLockFileÚActorÚget_user_idÚassure_directory_existsÚRemoteProgressÚCallableRemoteProgressÚrmtreeÚunbare_repoÚHIDE_WINDOWS_KNOWN_ERRORSÚwin32Úto_native_path_windows)Úabstractmethod)Úwraps)ÚPath)ÚurlsplitÚ
urlunsplit)	Ú	LazyMixinÚLockedFDÚ
bin_to_hexÚfile_contents_roÚfile_contents_ro_filepathÚ
hex_to_binÚmake_shaÚ
to_bin_shaÚ
to_hex_sha)ÚAnyÚAnyStrÚBinaryIOÚCallableÚDictÚ	GeneratorÚIOÚIteratorÚListÚOptionalÚPatternÚSequenceÚTupleÚTYPE_CHECKINGÚTypeÚTypeVarÚUnionÚcastÚoverload)ÚGit)ÚGitConfigParserÚSectionConstraint)ÚRemote)ÚRepo)	ÚFiles_TDÚHas_id_attributeÚHSH_TDÚLiteralÚPathLikeÚProtocolÚSupportsIndexÚTotal_TDÚruntime_checkableÚT_IterableObj)r	   r>   T)ÚboundÚ	covariantÚT_Actorr   )rG   ÚnameÚdefaultÚreturnc                 ó  •  [         R                  U    n[        R	                  SU 5        UR                  5       R                  5       nUS;   a  gUS;   a  g[        R	                  SXU5        U$ ! [         a    Us $ f = f)zyRead a boolean flag from an environment variable.

:return:
    The flag, or the `default` value if absent or ambiguous.
zlThe %s environment variable is deprecated. Its effect has never been documented and changes without warning.>   Ú Ú0ÚnoÚfalseF>   Ú1ÚyesÚtrueTz-%s has unrecognized value %r, treating as %r.)ÚosÚenvironÚKeyErrorÚ_loggerÚwarningÚstripÚlower)rJ   rK   ÚvalueÚadjusted_values       Ú–C:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\git/util.pyÚ_read_env_flagr_   u   s„   € ðÜ—
‘
˜4Ñ ˆô ‡O�OØvØôð
 —[‘[“]×(Ñ(Ó*€NàÐ1Ó1ØØÐ-Ó-ØÜ‡O�OÐCÀTÐRYÔZØ€Nøô ó ØŠðús   ‚A0 Á0A?Á>A?c                 óL   • [         R                  S:H  =(       a    [        X5      $ )zúRead a boolean flag from an environment variable on Windows.

:return:
    On Windows, the flag, or the `default` value if absent or ambiguous.
    On all other operating systems, ``False``.

:note:
    This only accesses the environment on Windows.
r   )ÚsysÚplatformr_   )rJ   rK   s     r^   Ú_read_win_env_flagrc   �   s   € ô �<‰<˜7Ñ"×D¤~°dÓ'DÐDó    r   ÚHIDE_WINDOWS_FREEZE_ERRORSÚTÚfunc.c           	      ól   ^ ^• SSK Jm  [        T 5      SSS[        S[        S[        4UU 4S jj5       nU$ )	zpMethods with this decorator raise :exc:`~git.exc.InvalidGitRepositoryError` if
they encounter a bare repository.é   )ÚInvalidGitRepositoryErrorÚselfr;   ÚargsÚkwargsrL   c                 ó|   >• U R                   R                  (       a  T" STR                  -  5      eT" U /UQ70 UD6$ )Nz/Method '%s' cannot operate on bare repositories)ÚrepoÚbareÚ__name__)rk   rl   rm   rj   rg   s      €€r^   ÚwrapperÚunbare_repo.<locals>.wrapper­   s;   ø€ à�9‰9�>�>Ù+Ð,]Ð`d×`mÑ`mÑ,mÓnÐná�DÐ*˜4Ò* 6Ñ*Ð*rd   )Úexcrj   r   r%   rf   )rg   rr   rj   s   ` @r^   r   r   §   sA   ù€ õ /ä
ˆ4ƒ[ð+�hð +¤sð +´cð +¼a÷ +ó ð+ð €Nrd   Únew_dirc              #   óÎ   #   • [         R                  " 5       n[         R                  " U 5         U v •  [         R                  " U5        g! [         R                  " U5        f = f7f)zÕContext manager to temporarily change directory.

This is similar to :func:`contextlib.chdir` introduced in Python 3.11, but the
context manager object returned by a single call to this function is not reentrant.
N)rU   ÚgetcwdÚchdir)ru   Úold_dirs     r^   Úcwdrz   ¹   s@   é € ô �iŠi‹k€GÜ‡H‚HˆWÔðØŠä
�Š�ÕøŒ�Š�Õüs   ‚,A%¯A
 ³A%Á
A"Á"A%r\   )NNNc              #   ó  #   • [         R                  " U 5      nU[         R                  U '    Sv •  Uc  [         R                  U 	 gU[         R                  U '   g! Uc  [         R                  U 	 f U[         R                  U '   f = f7f)z=Context manager to temporarily patch an environment variable.N)rU   ÚgetenvrV   )rJ   r\   Ú	old_values      r^   Ú	patch_envr~   È   sm   é € ô —	’	˜$“€IØ„B‡J�JˆtÑð)ÛàÑÜ—
‘
˜4Ñ à(ŒB�J‰J�tÒøð ÑÜ—
‘
˜4Ñ à(ŒB�J‰J�tÒüs   ‚*B­A ±)BÁ*BÂBÚpathc                 ó"  • S[         [        /[        4   S[        S[        SS4S jn[        R                  S:w  a  [
        R                  " U 5        g[        R                  S:¼  a  [
        R                  " XS	9  g[
        R                  " XS
9  g)zÛRemove the given directory tree recursively.

:note:
    We use :func:`shutil.rmtree` but adjust its behaviour to see whether files that
    couldn't be deleted are read-only. Windows will not remove them in that case.
Úfunctionr   Ú_excinforL   Nc                 óÀ   • [         R                  " U[        R                  5         U " U5        g! [         a#  n[
        (       a  SSKJn  U" SU 35      Uee SnAff = f)zeCallback for :func:`shutil.rmtree`.

This works as either a ``onexc`` or ``onerror`` style callback.
r   )ÚSkipTestz%FIXME: fails with: PermissionError
  N)rU   ÚchmodÚstatÚS_IWUSRÚPermissionErrorr   Úunittestr„   )r�   r   r‚   Úexr„   s        r^   ÚhandlerÚrmtree.<locals>.handlerÞ   sT   € ô 	�Š�”t—|‘|Ô$ð	Ù�T�NøÜó 	ß(Ò(Ý-áÐ!GÈÀtÐLÓMÐSUÐUØûð	ús   §0 °
AºAÁAr   )é   é   )Úonexc)Úonerror)r(   Ústrr%   ra   rb   Úshutilr   Úversion_info)r   r‹   s     r^   r   r   Ö   sn   € ðœ(¤C 5¬# :Ñ.ð ´cð ÄSð ÈTô ô" ‡|�|�wÓÜ�Š�dÕÜ	×	Ñ	˜WÓ	$Ü�Š�dÓ*ä�Š�dÓ,rd   c                 ó¾   • [         R                  " U 5      (       aB  [        R                  S:X  a  [        R
                  " U S5        [        R                  " U 5        gg)zSEnsure file deleted also on *Windows* where read-only files need special
treatment.r   iÿ  N)ÚospÚisfilera   rb   rU   r…   Úremove©r   s    r^   Úrmfiler™   ÷   s=   € ô ‡z‚z�$×ÑÜ�<‰<˜7Ó"Ü�HŠH�T˜5Ô!Ü
�	Š	�$�ð rd   ÚsourceÚdestinationÚ
chunk_sizec                 ó�   • Sn U R                  U5      nUR                  U5        U[        U5      -  n[        U5      U:  a   U$ MD  )z‹Copy all data from the `source` stream into the `destination` stream in chunks
of size `chunk_size`.

:return:
    Number of bytes written
r   )ÚreadÚwriteÚlen)rš   r›   rœ   ÚbrÚchunks        r^   r   r      sO   € ð 
€BØ
Ø—‘˜JÓ'ˆØ×Ñ˜%Ô Ø
Œc�%‹jÑˆÜˆu‹:˜
Ó"Øà€Iñ rd   ÚaÚpc                 ó  • [         R                  " U 5      nU Hk  n[         R                  " U5      nU(       d  M"  UR                  S5      (       a	  X#SS -  nMA  US:X  d  UR                  S5      (       a  X#-  nMc  USU-   -  nMm     U$ )ziJoin path tokens together similar to osp.join, but always use ``/`` instead of
possibly ``\`` on Windows.Ú/ri   NrN   )rU   ÚfspathÚ
startswithÚendswith)r£   r¤   r   Úbs       r^   r   r     sz   € ô �9Š9�Q‹<€DÛˆÜ�IŠI�a‹LˆÞÙØ�<‰<˜×ÑØ�a�b�E‰MŠDØ�R‹Z˜4Ÿ=™=¨×-Ñ-Ø‰IŠDà�C˜!‘G‰OŠDñ ð €Krd   c                 óR   • [         R                  " U 5      n U R                  SS5      $ )Nr¦   Ú\©rU   r§   Úreplacer˜   s    r^   r   r   &  s    € Ü�yŠy˜‹ˆØ�|‰|˜C Ó&Ð&rd   c                 óR   • [         R                  " U 5      n U R                  SS5      $ )Nr¬   r¦   r­   r˜   s    r^   r   r   *  s    € Ü�yŠy˜‹ˆØ�|‰|˜D #Ó&Ð&rd   c                 ó.   • [         R                  " U 5      $ ©N)rU   r§   r˜   s    r^   r   r   1  s   € Ü�yŠy˜‹Ðrd   c                 ó,   • [        [        U /UQ76 5      $ )z¤Like :func:`join_path`, but makes sure an OS native path is returned.

This is only needed to play it safe on Windows and to ensure nice paths that only
use ``\``.
)Úto_native_pathr   )r£   r¤   s     r^   r   r   7  s   € ô œ) AÐ*¨Ò*Ó+Ð+rd   c                 ó0  • [         R                  " [        R                  " U 5      5      u  p[        R                  c  [        R
                  4O[        R
                  [        R                  4nUR                  U5      =(       d    UR                  U5      $ )a]  Whether ``path`` has a root, including one encoded in a UNC drive.

On Windows, ``\directory`` is rooted on the current drive without being
absolute, while ``C:\directory`` has both a drive and a root. In contrast,
``directory`` and the drive-relative ``C:directory`` have no root.
UNC paths are rooted: ``\\server\share`` stores the share in the drive
returned by :func:`os.path.splitdrive`, while ``\\server\share\directory``
additionally has a rooted tail.
On POSIX, which has no drive concept, this simply distinguishes absolute
paths such as ``/directory`` from relative paths such as ``directory``.
)r•   Ú
splitdriverU   r§   ÚaltsepÚsepr¨   )r   ÚdriveÚtailÚ
separatorss       r^   Ú_is_path_rootedr»   @  s^   € ô —.’.¤§¢¨4£Ó1�K€EÜ Ÿi™iÑ/”"—&‘&‘´b·f±f¼b¿i¹iÐ5H€JØ�?‰?˜:Ó&×F¨%×*:Ñ*:¸:Ó*FÐFrd   Úrootc                 óF  • [         R                  " U5      nU(       d  U$ [        R                  " U5      u  p4[	        U5      nU(       a  U(       d  [        SU-  5      e[        R                  " [         R                  " U 5      5      n[        R                  " [        R                  " Xb5      5      n [        R                  " Xg/5      nX†:w  a  [        SU< SU< 35      e[        [        R                  " Xv5      5      n
[         R                  c  [         R                  4O[         R                  [         R                  4nUR                  U5      (       a!  U
S:w  a  U
R                  S5      (       d  U
S-  n
U
$ ! [
         a  n	[        SU< SU< 35      U	eSn	A	ff = f)a&  Return a normalized Git-style path confined to ``root``.

A Windows path such as ``\directory`` is rooted but not absolute. Resolve it
against the drive of ``root`` rather than treating it as relative to ``root``.
Drive-relative paths such as ``C:directory`` are rejected because their meaning
depends on process-global per-drive state.

For example, with ``root`` set to ``C:\repo`` on Windows:

* ``directory\file`` -> ``directory/file``
* ``directory\`` -> ``directory/``
* ``C:\repo\directory\file`` -> ``directory/file``
* ``\repo\directory\file`` -> ``directory/file``
* ``C:directory\file`` -> :exc:`ValueError`
* ``C:\other\file`` -> :exc:`ValueError`

On POSIX, ``/repo/directory/file`` under ``/repo`` similarly becomes
``directory/file``. A trailing separator is preserved as a Git-style ``/``.
z'Drive-relative path %r is not supportedzPath z is not in repository at NÚ.r¦   )rU   r§   r•   rµ   r»   Ú
ValueErrorÚabspathÚjoinÚ
commonpathr   Úrelpathr¶   r·   r©   )r¼   r   Úpath_strr¸   Ú_tailÚrootedÚroot_absÚpath_absÚcommon_pathÚeÚrelative_pathrº   s               r^   Ú_to_relative_pathrÌ   Q  s;  € ô( �yŠy˜‹€HÞØˆä—>’> (Ó+�L€EÜ˜XÓ&€FÞ–VÜÐBÀXÑMÓNÐNä�{Š{œ2Ÿ9š9 T›?Ó+€HÜ�{Š{œ3Ÿ8š8 HÓ7Ó8€Hð]Ü—n’n hÐ%9Ó:ˆð ÓÝÃÊ8ÐTÓUÐUä(¬¯ª°XÓ)HÓI€MÜ Ÿi™iÑ/”"—&‘&‘´b·f±f¼b¿i¹iÐ5H€JØ×Ñ˜×$Ñ$¨¸#Ó)=Àm×F\ÑF\Ð]`×FaÑFaØ˜ÑˆØÐøô ó ]ÝÃÊ8ÐTÓUÐ[\Ð\ûð]ús   Â4E= Å=
F ÆFÆF FÚis_filec                 ó    • U(       a  [         R                  " U 5      n [         R                  " U 5      (       d  [        R                  " U SS9  gg)a  Make sure that the directory pointed to by path exists.

:param is_file:
    If ``True``, `path` is assumed to be a file and handled correctly.
    Otherwise it must be a directory.

:return:
    ``True`` if the directory was created, ``False`` if it already existed.
T)Úexist_okF)r•   ÚdirnameÚisdirrU   Úmakedirs)r   rÍ   s     r^   r   r   ~  s6   € ö Ü�{Š{˜4Ó ˆä�9Š9�T�?‰?Ü
�Š�D 4Ò(ØØrd   c                  óÚ   • [         R                  R                  SS 5      n U (       a/  [        S U R	                  [         R
                  5       5       5      $ [        R                  S:X  a  gg)NÚPATHEXTc              3   ó@   #   • U  H  oR                  5       v •  M     g 7fr±   )Úupper)Ú.0r¤   s     r^   Ú	<genexpr>Ú&_get_exe_extensions.<locals>.<genexpr>”  s   é € ÐBÒ(A 1—W‘W—Y�YÒ(Aùs   ‚r   )z.BATz.COMz.EXE© )rU   rV   ÚgetÚtupleÚsplitÚpathsepra   rb   )rÔ   s    r^   Ú_get_exe_extensionsrß   ‘  sI   € Ü�j‰j�n‰n˜Y¨Ó-€GÞÜÑB¨¯©´b·j±jÔ(AÓBÓBÐBÜ	�‰˜Ó	 Ø'àrd   Úprogramc                 óà  ^• [        5       mS[        S[        4U4S jjn/ nU(       d  [        R                  S   n[        R
                  " U5      R                  [        R                  5       Hv  nUR                  S5      nU(       d  M  [        R                  " X@5      nU/T Vs/ s H
  oe< U< 3PM     sn-    H#  nU" U5      (       d  M  UR                  U5        M%     Mx     U$ s  snf )a  Perform a path search to assist :func:`is_cygwin_git`.

This is not robust for general use. It is an implementation detail of
:func:`is_cygwin_git`. When a search following all shell rules is needed,
:func:`shutil.which` can be used instead.

:note:
    Neither this function nor :func:`shutil.which` will predict the effect of an
    executable search on a native Windows system due to a :class:`subprocess.Popen`
    call without ``shell=True``, because shell and non-shell executable search on
    Windows differ considerably.
ÚfpathrL   c                 ó  >^ • [         R                  " T 5      =(       ai    [        R                  " T [        R                  5      =(       a=    [
        R                  S:g  =(       d#    T(       + =(       d    [        U 4S jT 5       5      $ )Nr   c              3   ób   >#   • U  H$  nTR                  5       R                  U5      v •  M&     g 7fr±   )rÖ   r©   )r×   Úextrâ   s     €r^   rØ   Ú,py_where.<locals>.is_exec.<locals>.<genexpr>°  s)   øé € ÐBwÒjvÐcfÀ5Ç;Á;Ã=×CYÑCYÐZ]×C^ÐC^Òjvùs   ƒ,/)r•   r–   rU   ÚaccessÚX_OKra   rb   Úany)râ   Úwinprog_extss   `€r^   Úis_execÚpy_where.<locals>.is_exec«  sW   ù€ ä�JŠJ�uÓ÷ Ü—	’	˜%¤§¡Ó)÷ô —‘ Ñ'×w¨|Ô+;×w¼sÔBwÑjvÓBwÓ?wð		
rd   ÚPATHÚ")rß   r‘   ÚboolrU   rV   r§   rÝ   rÞ   rZ   r•   rÁ   Úappend)	rà   r   rë   ÚprogsÚfolderÚexe_pathrÊ   Úfrê   s	           @r^   Úpy_whererõ   ›  sÁ   ø€ ô 'Ó(€Lð
”sð 
œt÷ 
ð €EÞÜ�z‰z˜&Ñ!ˆÜ—)’)˜D“/×'Ñ'¬¯
©
Ö3ˆØ—‘˜cÓ"ˆßˆ6Ü—x’x Ó0ˆHØ�ZÁ<Ó"PÂ<¸a©X²qÓ#9Á<Ñ"PÔP�Ù˜1—:“:Ø—L‘L –Oó Qñ	 4ð €Lùò #Qs   Â(C+r¸   Úexpand_varsc                 óÜ  • [         R                  " U5      (       a
  U (       d  UnO U=(       aG    [         R                  " U(       a*  [         R                  " [         R                  " U5      5      OU5      n[         R                  " U5      (       a  U (       a  UnO+[        U5      nOU (       a  SU R                  5       < SU< 3n[        R                  " U5      nUR                  SS5      $ )Nz/proc/cygdrive/r¦   r¬   )
r•   ÚisabsÚnormpathÚ
expandvarsÚ
expanduserÚcygpathr[   rU   r§   r®   )r¸   r   rö   r¤   Úp_strs        r^   Ú
_cygexpathrþ   Á  s‘   € Ü
‡y‚y�‡�žuð ‰à×`”S—\’\Î+¤#§.¢.´·²ÀÓ1EÔ"FÐ[_Ó`ˆÜ�9Š9�Q�<‰<Þà‘ä˜A“J‘ßØ*/¯+©+®-ºÐ;ˆAÜ�IŠI�a‹L€EØ�=‰=˜˜sÓ#Ð#rd   z*\\\\\?\\UNC\\([^\\]+)\\([^\\]+)(?:\\(.*))?c           	      ó>   • SU < SU< SUR                  SS5      < 3$ )Nú//r¦   r¬   )r®   )ÚserverÚshareÚ	rest_paths      r^   Ú<lambda>r  Ù  s   � »&Ã%È×IZÑIZÐ[_ÐadÕIeÑ*frd   z\\\\\?\\(\w):[/\\](.*)z(\w):[/\\](.*)z	file:(.*)c                 ó   • U $ r±   rÚ   )r  s    r^   r  r  Þ  s   € ¹	rd   z(\w{2,}:.*)c                 ó   • U $ r±   rÚ   )Úurls    r^   r  r  ß  s   € ©crd   Ú_cygpath_parsersc                 óN  • [         R                  " U 5      n U R                  S5      (       dx  [         Hd  u  p#nUR	                  U 5      nU(       d  M   U[
        L a  U" UR                  5       SU06n OU" UR                  5       6 n U(       a	  [        XS9n   U $    [        SXS9n U $ )zJUse :meth:`git.cmd.Git.polish_url` instead, that works on any environment.)z	/cygdriver   z/proc/cygdriverö   )rö   N)rU   r§   r¨   r  Úmatchrþ   Úgroupsrü   )r   rö   ÚregexÚparserÚrecurser
  s         r^   rü   rü   ã  s˜   € ä�9Š9�T‹?€Dà�?‰?Ð@×AÑAß&6Ñ"ˆE˜7Ø—K‘K Ó%ˆEßˆuØœZÒ'Ù! 5§<¡<£>ÐK¸{ÑK‘Dá! 5§<¡<£>Ð2�DÞÜ" 4ÑA�DØð €Kñ '7ô ˜d DÑBˆDà€Krd   z(?:/proc)?/cygdrive/(\w)(/.*)?c                 óî   • [         R                  " U 5      n [        R                  U 5      nU(       a2  UR	                  5       u  p#UR                  5       < SU=(       d    S< 3n U R                  SS5      $ )NÚ:rN   r¦   r¬   )rU   r§   Ú_decygpath_regexr
  r  rÖ   r®   )r   Úmr¸   r  s       r^   Ú	decygpathr  û  sW   € Ü�9Š9�T‹?€DÜ×Ñ˜tÓ$€AÞØŸ8™8›:ÑˆØŸ+™+ž-¨¯°b©Ð9ˆà�<‰<˜˜TÓ"Ð"rd   Ú_is_cygwin_cacheÚgit_executablec                 ó¼  • [         R                  U 5      nUGc  Sn [        R                  " U 5      nU(       d-  [	        U 5      nU(       a  [        R                  " US   5      OSn[        R
                  " US5      n[        U5      R                  5       (       a*  [        R                  " U[        R                  5      (       d$  [        R                  SU S35        U[         U '   U$ [        R                  " U/[        R                  SS9nUR!                  5       u  pgS	U;   nU[         U '   U$ ! ["         a   n[        R                  S
U5         S nAN0S nAff = f)NFr   rN   Úunamez&Failed checking if running in CYGWIN: z is not an executableT)ÚstdoutÚuniversal_newlinesÚCYGWINz/Failed checking if running in CYGWIN due to: %r)r  rÛ   r•   rÐ   rõ   rÁ   r   rÍ   rU   rç   rè   rX   ÚdebugÚ
subprocessÚPopenÚPIPEÚcommunicateÚ	Exception)	r  Ú	is_cygwinÚgit_dirÚresÚ	uname_cmdÚprocessÚ	uname_outÚ_rŠ   s	            r^   Ú_is_cygwin_gitr(  
  s#  € Ü ×$Ñ$ ^Ó4€IØÒØˆ	ð	QÜ—k’k .Ó1ˆGÞÜ˜~Ó.�Þ14œ#Ÿ+š+ c¨!¡fÔ-¸"�ô Ÿš ¨'Ó2ˆIä˜“O×+Ñ+×-Ñ-´"·)²)¸IÄrÇwÁw×2OÑ2OÜ—‘Ð FÀyÀkÐQfÐgÔhØ3<Ô  Ñ0Ø Ð ä ×&Ò&¨	 {¼:¿?¹?Ð_cÑdˆGØ"×.Ñ.Ó0‰LˆIà  IÑ-ˆIð ,5Ô˜Ñ(àÐøô	 ó 	QÜ�M‰MÐKÈR×PÑPûð	Qús   �CD1 Ã*<D1 Ä1
EÄ;EÅEc                 ó   • g r±   rÚ   ©r  s    r^   Úis_cygwin_gitr+  '  ó   € Ø;>rd   c                 ó   • g r±   rÚ   r*  s    r^   r+  r+  +  s   € Ø58rd   c                 ó²   • [         R                  S[        R                  < SU < 35        [        R                  S:w  a  gU c  g[	        [        U 5      5      $ )Nzsys.platform=z, git_executable=ÚcygwinF)rX   r  ra   rb   r(  r‘   r*  s    r^   r+  r+  /  sJ   € ä‡M�M�M¤#§,¡,Ñ!1Ð1BÀ>ÑBTÐUÔVÜ
‡|�|�xÓØØ	Ñ	Øäœc .Ó1Ó2Ð2rd   c                  ó`   • [         R                  " 5       < S[        R                  " 5       < 3$ )zM:return: String identifying the currently active system user as ``name@node``Ú@)ÚgetpassÚgetuserrb   ÚnoderÚ   rd   r^   r   r   :  s   € ä—o’oÖ'¬¯ª­Ð9Ð9rd   Úproc)zsubprocess.Popen[Any]zGit.AutoInterruptrm   c                 ó(   • U R                   " S0 UD6  g)zTWait for the process (clone, fetch, pull or push) and handle its errors
accordingly.NrÚ   )Úwait)r5  rm   s     r^   Úfinalize_processr8  ?  s   € ð 	‡I‚IÑ�Órd   c                 ó   • g r±   rÚ   ©r¤   rö   s     r^   Úexpand_pathr;  F  r,  rd   c                 ó   • g r±   rÚ   r:  s     r^   r;  r;  J  s   € ð rd   c                 óX  • U c  g  [        U [        5      (       a  U R                  5       $ [        R                  " [
        R                  " U 5      5      nU(       a  [        R                  " U5      n[        R                  " [        R                  " U5      5      $ ! [         a     g f = fr±   )Ú
isinstancer   Úresolver•   rû   rU   r§   rú   rù   rÀ   r   )r¤   rö   Úexpanded_paths      r^   r;  r;  P  sy   € Ø�yØðÜ�aœ×ÑØ—9‘9“;ÐÜŸš¤r§y¢y°£|Ó4ˆÞÜŸNšN¨=Ó9ˆMÜ�|Š|œCŸKšK¨Ó6Ó7Ð7øÜó Ùðús   †$B «A0B Â
B)Â(B)Úcmdlinec                 ó  • / n[        U 5       GH[  u  p#UR                  U5        UR                  S5      u  pEnUR                  S5      u  pxn	U(       a`  U(       aY  UR                  5       R	                  S5      (       a5  UR                  5       R                  5       S:X  a  U< U< U< U< S3X'   M¦   [        U5      n
U
R                  c  U
R                  c  MÎ  U
R                  b3  U
R                  U
R                  R                  U
R                  S5      S9n
U
R                  b3  U
R                  U
R                  R                  U
R                  S5      S9n
[        U
5      X'   GM^     U$ ! [         a     GMp  f = f)zõRedact credentials in URLs and HTTP Authorization extra headers in a command line.

If nothing is found, this just returns the command line as-is.

This should be used for every log line that print a command line, as well as
exception messages.
Ú=r  z.extraheaderÚauthorizationz *****z*****)Únetloc)Ú	enumeraterð   Ú	partitionr[   r©   rZ   r   ÚpasswordÚusernameÚ_replacerE  r®   r   r¿   )rA  Únew_cmdlineÚindexÚto_parseÚ
config_keyÚ	separatorÚheaderÚheader_nameÚcolonr'  r  s              r^   Úremove_password_if_presentrS  ^  sL  € ð €KÜ$ W×-‰ˆØ×Ñ˜8Ô$Ø(0×(:Ñ(:¸3Ó(?Ñ%ˆ
˜vØ &× 0Ñ 0°Ó 5Ñˆ˜AæÞØ× Ñ Ó"×+Ñ+¨N×;Ñ;Ø×!Ñ!Ó#×)Ñ)Ó+¨Ó>â5?ÂÊKÓY^Ð!_ˆKÑÙð	Ü˜8Ó$ˆCà�|‰|Ñ#¨¯©Ñ(<Ùà�|‰|Ñ'Ø—l‘l¨#¯*©*×*<Ñ*<¸S¿\¹\È7Ó*S�lÐT�Ø�|‰|Ñ'Ø—l‘l¨#¯*©*×*<Ñ*<¸S¿\¹\È7Ó*S�lÐT�Ü!+¨C£ˆKÔñ- .ð4 Ðøô ó 	ãð	ús   Â5%E0ÃBE0Å0
E?Å>E?c                   ór  • \ rS rSr% SrSr\\S'   \" \5       V Vs/ s H  nSU-  PM
     snn u	  r	r
rrrrrrr\	\
-  r\) rSrSrSr\R0                  " S	5      r\R0                  " S
5      rSS jrS\S\\   4S jrS\ \!/S4   4S jr"S\!SS4S jr#  SS\S\$\!\%4   S\$\!\%S4   S\!SS4
S jjr&Sr'gs  snn f )r   i‰  zÂHandler providing an interface to parse progress information emitted by
:manpage:`git-push(1)` and :manpage:`git-fetch(1)` and to dispatch callbacks
allowing subclasses to react to the progress.é	   Ú_num_op_codesri   zdone.z, )Ú	_cur_lineÚ	_seen_opsÚerror_linesÚother_linesz%(remote: )?([\w\s]+):\s+()(\d+)()(.*)z2(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)rL   Nc                 ó<   • / U l         S U l        / U l        / U l        g r±   )rX  rW  rY  rZ  ©rk   s    r^   Ú__init__ÚRemoteProgress.__init__©  s    € Ø$&ˆŒØ(,ˆŒØ&(ˆÔØ&(ˆÕrd   Úlinec                 ó  • [        U[        5      (       a  UR                  S5      nOUnX l        U R                  R	                  S5      (       a&  U R
                  R                  U R                  5        gSu  p4U R                  R                  U5      nUc  U R                  R                  U5      nU(       d-  U R                  U5        U R                  R                  U5        gSnUR                  5       u  pxp“pJUS:X  a  X`R                  -  nO�US:X  a  X`R                  -  nO{US:X  a  X`R                  -  nOfUS	:X  a  X`R                   -  nOQUS
:X  a  X`R"                  -  nO<US:X  a  X`R$                  -  nO'US:X  a  X`R&                  -  nOU R                  U5        gX`R(                  ;  a)  U R(                  R                  U5        X`R*                  -  nU
c  Sn
U
R-                  5       n
U
R/                  U R0                  5      (       a'  X`R2                  -  nU
S[5        U R0                  5      *  n
U
R-                  U R6                  5      n
U R9                  UU=(       a    [;        U5      U=(       a    [;        U5      U
5        g)aê  Parse progress information from the given line as retrieved by
:manpage:`git-push(1)` or :manpage:`git-fetch(1)`.

- Lines that do not contain progress info are stored in :attr:`other_lines`.
- Lines that seem to contain an error (i.e. start with ``error:`` or ``fatal:``)
  are stored in :attr:`error_lines`.

The base implementation returns ``None``. Subclasses may return another
value for compatibility with existing overrides, but callers should treat
the return value as unspecified.
zutf-8)zerror:zfatal:N)NNr   zCounting objectszCompressing objectszWriting objectszReceiving objectszResolving deltaszFinding sourceszChecking out filesrN   )r>  ÚbytesÚdecoderW  r¨   rY  rð   Úre_op_relativer
  Úre_op_absoluteÚline_droppedrZ  r  ÚCOUNTINGÚCOMPRESSINGÚWRITINGÚ	RECEIVINGÚ	RESOLVINGÚFINDING_SOURCESÚCHECKING_OUTrX  ÚBEGINrZ   r©   Ú
DONE_TOKENÚENDr    ÚTOKEN_SEPARATORÚupdateÚfloat)rk   r_  Úline_strÚ	cur_countÚ	max_countr
  Úop_codeÚ_remoteÚop_nameÚ_percentÚmessages              r^   Ú_parse_progress_lineÚ#RemoteProgress._parse_progress_line¯  sF  € ô" �dœE×"Ñ"Ø—{‘{ 7Ó+‰HàˆHØ!Œà�>‰>×$Ñ$Ð%9×:Ñ:Ø×Ñ×#Ñ# D§N¡NÔ3Øà)Ñˆ	Ø×#Ñ#×)Ñ)¨(Ó3ˆØ‰=Ø×'Ñ'×-Ñ-¨hÓ7ˆEæØ×Ñ˜hÔ'Ø×Ñ×#Ñ# HÔ-Øð ˆØDIÇLÁLÃNÑAˆ˜(¨yð Ð(Ó(Ø—}‘}Ñ$‰GØÐ-Ó-Ø×'Ñ'Ñ'‰GØÐ)Ó)Ø—|‘|Ñ#‰GØÐ+Ó+Ø—~‘~Ñ%‰GØÐ*Ó*Ø—~‘~Ñ%‰GØÐ)Ó)Ø×+Ñ+Ñ+‰GØÐ,Ó,Ø×(Ñ(Ñ(‰Gð ×Ñ˜hÔ'ð ð Ÿ.™.Ó(Ø�N‰N×!Ñ! 'Ô*Ø—z‘zÑ!ˆGð ‰?ØˆGð —-‘-“/ˆØ×Ñ˜DŸO™O×,Ñ,Ø—x‘xÑˆGØÐ5¤ T§_¡_Ó!5Ð 5Ð6ˆGà—-‘- × 4Ñ 4Ó5ˆà�‰ØØ×*œ% 	Ó*Ø×*œ% 	Ó*Øô		
ð rd   c                 ó(   ^ • S[         SS4U 4S jjnU$ )zš
:return:
    A progress handler suitable for :func:`~git.cmd.handle_process_output`,
    passing lines on to this progress handler in a suitable format.
r_  rL   Nc                 óD   >• TR                  U R                  5       5        g r±   )r{  Úrstrip)r_  rk   s    €r^   r‹   Ú3RemoteProgress.new_message_handler.<locals>.handler  s   ø€ Ø×%Ñ% d§k¡k£mÕ4rd   )r&   )rk   r‹   s   ` r^   Únew_message_handlerÚ"RemoteProgress.new_message_handler  s   ø€ ð	5œ&ð 	5 T÷ 	5ð
 ˆrd   c                 ó   • g)zICalled whenever a line could not be understood and was therefore dropped.NrÚ   )rk   r_  s     r^   re  ÚRemoteProgress.line_dropped  s   € àrd   rv  rt  ru  rz  c                 ó   • g)a?  Called whenever the progress changes.

:param op_code:
    Integer allowing to be compared against Operation IDs and stage IDs.

    Stage IDs are :const:`BEGIN` and :const:`END`. :const:`BEGIN` will only be
    set once for each Operation ID as well as :const:`END`. It may be that
    :const:`BEGIN` and :const:`END` are set at once in case only one progress
    message was emitted due to the speed of the operation. Between
    :const:`BEGIN` and :const:`END`, none of these flags will be set.

    Operation IDs are all held within the :const:`OP_MASK`. Only one Operation
    ID will be active per call.

:param cur_count:
    Current absolute count of items.

:param max_count:
    The maximum count of items we expect. It may be ``None`` in case there is no
    maximum number of items or if it is (yet) unknown.

:param message:
    In case of the :const:`WRITING` operation, it contains the amount of bytes
    transferred. It may possibly be used for other purposes as well.

:note:
    You may read the contents of the current line in
    :attr:`self._cur_line <_cur_line>`.
NrÚ   )rk   rv  rt  ru  rz  s        r^   rq  ÚRemoteProgress.update  s   € ðH 	rd   ©rL   N©NrN   )(rq   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__rV  ÚintÚ__annotations__Úrangerm  ro  rf  rg  rh  ri  rj  rk  rl  Ú
STAGE_MASKÚOP_MASKrn  rp  Ú	__slots__ÚreÚcompilerd  rc  r]  r&   r.   Úobjectr{  r(   r‘   r�  re  r5   rr  rq  Ú__static_attributes__)r×   Úxs   00r^   r   r   ‰  s;  ‡ ñ5ð €M�3Óñ ˜}Ô-Ô.Ò-�AˆˆaŒÑ-Ò.ñ
ØØØØØØØØØà˜‘€JØˆk€Gà€JØ€Oð€Ið —Z’ZÐ HÓI€NØ—Z’ZÐ UÓV€Nô)ð\¨ð \°H¸VÑ4Dô \ð| X¨s¨e°T¨kÑ%:ô ð ð ¨ô ð .2Øñ$àð$ð ˜˜e˜Ñ$ð$ð ˜˜e TÐ)Ñ*ð	$ð
 ð$ð 
÷$ð $ùóM 	/s   œB3r   c                   ó\   ^ • \ rS rSrSrSrS\S\4   SS4U 4S jjrS	\S
\SS4S jr	Sr
U =r$ )r   iF  aˆ  A :class:`RemoteProgress` implementation forwarding updates to any callable.

:note:
    Like direct instances of :class:`RemoteProgress`, instances of this
    :class:`CallableRemoteProgress` class are not themselves directly callable.
    Rather, instances of this class wrap a callable and forward to it. This should
    therefore not be confused with :class:`git.types.CallableProgress`.
©Ú	_callableÚfn.rL   Nc                 ó.   >• Xl         [        TU ]	  5         g r±   )rš  Úsuperr]  )rk   r›  Ú	__class__s     €r^   r]  ÚCallableRemoteProgress.__init__R  s   ø€ ØŒÜ‰ÑÕrd   rl   rm   c                 ó(   • U R                   " U0 UD6  g r±   r™  )rk   rl   rm   s      r^   rq  ÚCallableRemoteProgress.updateV  s   € Ø�Š˜Ð' Ó'rd   )rq   r‰  rŠ  r‹  rŒ  r’  r(   r%   r]  rq  r–  Ú__classcell__©rž  s   @r^   r   r   F  sJ   ø† ñð €Ið˜8 C¨ HÑ-ð °$÷ ð(˜Cð (¨3ð (°4÷ (ò (rd   r   c                   óT   • \ rS rSr\R
                  " S5      rS\S\S\\	   4S jr
Srg)	Ú_DeprecatedActorNameEmailRegexiZ  z(.*) <(.*?)>Ú	_instanceÚ_ownerrL   c                 óN   • [         R                  " S[        SS9  U R                  $ )Na  Actor.name_email_regex is deprecated and will be removed in GitPython 4.0.0 because searching long malformed strings with it can take quadratic time. Use Actor.from_string() to parse actor identities, or Actor(name, email) when the fields are already separate.é   ©Ú
stacklevel)ÚwarningsÚwarnÚDeprecationWarningÚ_pattern)rk   r¦  r§  s      r^   Ú__get__Ú&_DeprecatedActorNameEmailRegex.__get__]  s(   € Ü�ŠðJô Øò	
ð �}‰}Ðrd   rÚ   N)rq   r‰  rŠ  r‹  r“  r”  r¯  r%   r/   r‘   r°  r–  rÚ   rd   r^   r¥  r¥  Z  s.   † Ø�zŠz˜/Ó*€Hð ð ¨cð °g¸c±l÷ rd   r¥  c            
       ó\  • \ rS rSrSr\" 5       rSrSrSr	Sr
SrSrS	rS\\   S\\   S
S4S jrS\S
\4S jrS\S
\4S jrS
\4S jrS
\4S jrS
\4S jr\S\\   S\S
\4S j5       r\r\ SS\S\S\S   S
S 4S jj5       r\ SS\S   S
S 4S jj5       r \ SS\S   S
S 4S jj5       r!Sr"g)r   ih  z­Actors hold information about a person acting on the repository. They can be
committers and authors or anything with a name and an email as mentioned in the git
log entries.ÚGIT_AUTHOR_NAMEÚGIT_AUTHOR_EMAILÚGIT_COMMITTER_NAMEÚGIT_COMMITTER_EMAILrJ   Úemail©rJ   r·  rL   Nc                 ó   • Xl         X l        g r±   r¸  )rk   rJ   r·  s      r^   r]  ÚActor.__init__|  s   € ØŒ	Ø�
rd   Úotherc                 ót   • U R                   UR                   :H  =(       a    U R                  UR                  :H  $ r±   r¸  ©rk   r»  s     r^   Ú__eq__ÚActor.__eq__€  s'   € Ø�y‰y˜EŸJ™JÑ&×D¨4¯:©:¸¿¹Ñ+DÐDrd   c                 ó   • X:X  + $ r±   rÚ   r½  s     r^   Ú__ne__ÚActor.__ne__ƒ  s   € ØÒ"Ð"rd   c                 óD   • [        U R                  U R                  45      $ r±   )ÚhashrJ   r·  r\  s    r^   Ú__hash__ÚActor.__hash__†  s   € Ü�T—Y‘Y §
¡
Ð+Ó,Ð,rd   c                 ó@   • U R                   (       a  U R                   $ S$ rˆ  )rJ   r\  s    r^   Ú__str__ÚActor.__str__‰  s   € Ø ŸIŸIˆt�y‰yÐ-¨2Ð-rd   c                 ó@   • SU R                   < SU R                  < S3$ )Nz<git.Actor "z <z>">r¸  r\  s    r^   Ú__repr__ÚActor.__repr__Œ  s   � Ø*.¯)¬)°T·Z´ZÐ@Ð@rd   ÚclsÚstringc                 óÞ   • UR                  S5      S   nUR                  S5      nUR                  SUS-   5      nUS:¼  a%  US:¼  a  U " USU R                  5       X#S-   U 5      $ U " US5      $ )zºCreate an :class:`Actor` from a string.

:param string:
    The string, which is expected to be in regular git format::

        John Doe <jdoe@example.com>

:return:
    :class:`Actor`
Ú
r   Ú<Ú>ri   N)rG  Úfindr  )rÍ  rÎ  r_  Úleft_bracketÚright_brackets        r^   Úfrom_stringÚActor.from_string�  s€   € ð ×Ñ Ó% aÑ(ˆØ—y‘y “~ˆØŸ	™	 # |°aÑ'7Ó8ˆØ˜1Ó °!Ó!3Ù�t˜M˜\Ð*×1Ñ1Ó3°TÈÑ:JÈ]Ð5[Ó\Ð\ñ �6˜4Ó Ð rd   Úenv_nameÚ	env_emailÚconfig_reader)Nr9   z"SectionConstraint[GitConfigParser]c                 óÌ  ^^• [        SS5      nS mS[        4U4S jjmS[        4U4S jjnSXR                  U4SX R                  T44 H&  u  pgp‰ [        R
                  U   n
[        XFU
5        M(     U$ ! [         ab    Ub7   UR                  SU5      n
O! [         a
    U	" 5       n
 Of = f[        XFU
5        [        XF5      (       d  [        XFU	" 5       5         M”   M—  f = f)NrN   rL   c                  ó*   >• T (       d
  [        5       m T $ r±   )r   )Úuser_ids   €r^   Údefault_emailÚ(Actor._main_actor.<locals>.default_email°  s   ø€ æÜ%›-�ØˆNrd   c                  ó6   >• T " 5       R                  S5      S   $ )Nr1  r   )rÝ   )rÞ  s   €r^   Údefault_nameÚ'Actor._main_actor.<locals>.default_name¶  s   ø€ Ù “?×(Ñ(¨Ó-¨aÑ0Ð0rd   rJ   r·  Úuser)r   r‘   Ú	conf_nameÚ
conf_emailrU   rV   ÚsetattrrW   rÛ   r   Úgetattr)rÍ  rØ  rÙ  rÚ  Úactorrá  ÚattrÚevarÚcvarrK   ÚvalrÞ  rÝ  s              @@r^   Ú_main_actorÚActor._main_actor¦  sê   ù€ ô �b˜"“ˆØˆð	œs÷ 	ð	1œc÷ 	1ð �XŸ}™}¨lÐ;Ø�i§¡°Ð?ó*
Ñ%ˆD˜ð4Ü—j‘j Ñ&�Ü˜ SÖ)ñ*
ð& ˆøô ó 	4Ø Ñ,ð(Ø+×/Ñ/°¸Ó=™øÜ$ó (Ù%›išð(úä˜E¨Ô-ä˜u×+Ñ+Ü˜E©«×3ò ,ð	4ús6   ÁA7Á7C#ÂBÂC#ÂB,Â)C#Â+B,Â,0C#Ã"C#c                 óP   • U R                  U R                  U R                  U5      $ )a‰  
:return:
    :class:`Actor` instance corresponding to the configured committer. It
    behaves similar to the git implementation, such that the environment will
    override configuration values of `config_reader`. If no value is set at all,
    it will be generated.

:param config_reader:
    ConfigReader to use to retrieve the values from in case they are not set in
    the environment.
)rí  Úenv_committer_nameÚenv_committer_email©rÍ  rÚ  s     r^   Ú	committerÚActor.committerÎ  s$   € ð �‰˜s×5Ñ5°s×7NÑ7NÐP]Ó^Ð^rd   c                 óP   • U R                  U R                  U R                  U5      $ )z~Same as :meth:`committer`, but defines the main author. It may be specified
in the environment, but defaults to the committer.)rí  Úenv_author_nameÚenv_author_emailrò  s     r^   ÚauthorÚActor.authorß  s#   € ð �‰˜s×2Ñ2°C×4HÑ4HÈ-ÓXÐXrd   )r·  rJ   r±   )#rq   r‰  rŠ  r‹  rŒ  r¥  Úname_email_regexrö  r÷  rð  rñ  rä  rå  r’  r.   r‘   r]  r%   rï   r¾  rÁ  r�  rÅ  rÈ  rË  Úclassmethodr3   rI   rÖ  Ú_from_stringr5   rí  ró  rø  r–  rÚ   rd   r^   r   r   h  s‰  † ññ 6Ó7Ðð (€OØ)ÐØ-ÐØ/Ðð €IØ€Jà!€Ið˜X c™]ð °8¸C±=ð ÀTô ðE˜Cð E Dô Eð#˜Cð # Dô #ð-˜#ô -ð.˜ô .ðA˜#ô Að ð!˜˜g™ð !°ð !¸ó !ó ð!ð( €Làð
 _cñ	%àð%ð ð%ð ÐZÑ[ð	%ð
 
ô%ó ð%ðN àcgñ_Ø!Ð"_Ñ`ð_à	ô_ó ð_ð  àcgñYØ!Ð"_Ñ`ðYà	ôYó óYrd   c                   ó\   • \ rS rSrSrSrS\S\\\	4   SS4S jr
\S	S
S\SS 4S j5       rSrg)r   iè  a©  Represents stat information as presented by git at the end of a merge. It is
created from the output of a diff operation.

Example::

 c = Commit( sha1 )
 s = c.stats
 s.total         # full-stat-dict
 s.files         # dict( filepath : stat-dict )

``stat-dict``

A dictionary with the following keys and values::

  deletions = number of deleted lines as int
  insertions = number of inserted lines as int
  lines = total number of lines changed as int, or deletions + insertions
  change_type = type of change as str, A|C|D|M|R|T|U|X|B

``full-stat-dict``

In addition to the items in the stat-dict, it features additional information::

 files = number of changed files as int
©ÚtotalÚfilesrÿ  r   rL   Nc                 ó   • Xl         X l        g r±   rþ  )rk   rÿ  r   s      r^   r]  ÚStats.__init__  s   € ØŒ
Ø�
rd   ro   r<   Útextc                 óÐ  • SSSSS.0 S.nUR                  5        H·  nUR                  S5      u  pVpxUS:g  =(       a    [        U5      =(       d    Sn	US:g  =(       a    [        U5      =(       d    Sn
US   S==   U	-  ss'   US   S==   U
-  ss'   US   S	==   Xš-   -  ss'   US   S
==   S-  ss'   U	U
Xš-   US.nX³S
   UR                  5       '   M¹     [	        US   US
   5      $ )zqCreate a :class:`Stats` object from output retrieved by
:manpage:`git-diff(1)`.

:return:
    :class:`git.Stats`
r   )Ú
insertionsÚ	deletionsÚlinesr   rþ  Ú	Ú-rÿ  r  r  r  r   ri   )r  r  r  Úchange_type)Ú
splitlinesrÝ   r�  rZ   r   )rÍ  ro   r  Úhshr_  r
  Úraw_insertionsÚraw_deletionsÚfilenamer  r  Ú
files_dicts               r^   Ú_list_from_stringÚStats._list_from_string	  s  € ð %&°AÀÈAÑNØñ
ˆð —O‘OÖ%ˆDØEIÇZÁZÐPTÓEUÑBˆ[¨-Ø'¨3Ñ.×F´3°~Ó3F×KÈ!ˆJØ%¨Ñ,×C´°]Ó1C×HÀqˆIØ�‰L˜Ó&¨*Ñ4Ó&Ø�‰L˜Ó%¨Ñ2Ó%Ø�‰L˜Ó! ZÑ%;Ñ;Ó!Ø�‰L˜Ó! QÑ&Ó!à(Ø&Ø#Ñ/Ø*ñ	$ˆJð .8�‰L˜Ÿ™Ó)Ó*ñ &ô �S˜‘\ 3 w¡<Ó0Ð0rd   )r   rÿ  )rq   r‰  rŠ  r‹  rŒ  r’  rD   r)   rA   r=   r]  rû  r‘   r  r–  rÚ   rd   r^   r   r   è  s[   † ñð4 #€Ið˜hð ¨t°H¸hÐ4FÑ/Gð ÈDô ð ð1 Vð 1°3ð 1¸7ó 1ó ó1rd   r   c                   óp   • \ rS rSrSrSrS\\   SS4S jrS\S\	4S	 jr
S\4S
 jrS\4S jrS\	4S jrSrg)r   i(  a  Wrapper around a file-like object that remembers the SHA1 of the data written to
it. It will write a sha when the stream is closed or if asked for explicitly using
:meth:`write_sha`.

Only useful to the index file.

:note:
    Based on the dulwich project.
)rô   Úsha1rô   rL   Nc                 ó0   • Xl         [        S5      U l        g )Nrd   )rô   r"   r  )rk   rô   s     r^   r]  ÚIndexFileSHA1Writer.__init__5  s   € ØŒÜ˜S“Mˆ�	rd   Údatac                 ón   • U R                   R                  U5        U R                  R                  U5      $ r±   )r  rq  rô   rŸ   )rk   r  s     r^   rŸ   ÚIndexFileSHA1Writer.write9  s'   € Ø�	‰	×Ñ˜ÔØ�v‰v�|‰|˜DÓ!Ð!rd   c                 óp   • U R                   R                  5       nU R                  R                  U5        U$ r±   )r  Údigestrô   rŸ   ©rk   Úshas     r^   Ú	write_shaÚIndexFileSHA1Writer.write_sha=  s)   € Ø�i‰i×ÑÓ ˆØ�‰�‰�SÔØˆ
rd   c                 óZ   • U R                  5       nU R                  R                  5         U$ r±   )r  rô   Úcloser  s     r^   r!  ÚIndexFileSHA1Writer.closeB  s    € Ø�n‰nÓˆØ�‰�‰ŒØˆ
rd   c                 ó6   • U R                   R                  5       $ r±   )rô   Útellr\  s    r^   r$  ÚIndexFileSHA1Writer.tellG  s   € Ø�v‰v�{‰{‹}Ðrd   )rq   r‰  rŠ  r‹  rŒ  r’  r+   ra  r]  r�  rŸ   r  r!  r$  r–  rÚ   rd   r^   r   r   (  s\   † ñð €Ið"˜"˜U™)ð "¨ô "ð"˜%ð " Cô "ð˜5ô ð
�uô ð
�c÷ rd   r   c                   ór   • \ rS rSrSrSrS\SS4S jrSS jrS\	4S	 jr
S\4S
 jrSS jrSS jrSS jrSrg)r   iK  a  Provides methods to obtain, check for, and release a file based lock which
should be used to handle concurrent access to the same file.

As we are a utility class to be derived from, we only use protected methods.

Locks will automatically be released on destruction.
©Ú
_file_pathÚ
_owns_lockÚ	file_pathrL   Nc                 ó   • Xl         SU l        g )NFr'  )rk   r*  s     r^   r]  ÚLockFile.__init__V  s   € Ø#ŒØˆ�rd   c                 ó$   • U R                  5         g r±   )Ú_release_lockr\  s    r^   Ú__del__ÚLockFile.__del__Z  s   € Ø×ÑÕrd   c                 ó    • SU R                   -  $ )z:return: Path to lockfilez%s.lock)r(  r\  s    r^   Ú_lock_file_pathÚLockFile._lock_file_path]  s   € à˜DŸO™OÑ,Ð,rd   c                 ó   • U R                   $ )zƒ
:return:
    True if we have a lock and if the lockfile still exists

:raise AssertionError:
    If our lock-file does not exist.
)r)  r\  s    r^   Ú	_has_lockÚLockFile._has_locka  s   € ð �‰Ðrd   c                 ój  • U R                  5       (       a  gU R                  5       n[        R                  " U5      (       a  [	        SU R
                  < SU< S35      e [        USS9    SSS5        SU l	        g! , (       d  f       N= f! [         a  n[	        [        U5      5      UeSnAff = f)zªCreate a lock file as flag for other instances, mark our instance as
lock-holder.

:raise IOError:
    If a lock was already present or a lock file could not be written.
NzLock for file z did already exist, delete z in case the lock is illegalÚw)ÚmodeT)
r5  r2  r•   r–   ÚIOErrorr(  ÚopenÚOSErrorr‘   r)  )rk   Ú	lock_filerÊ   s      r^   Ú_obtain_lock_or_raiseÚLockFile._obtain_lock_or_raisek  s”   € ð �>‰>×ÑØØ×(Ñ(Ó*ˆ	Ü�:Š:�i× Ñ Ýà—?”?£Ið/óð ð
	)Ü�i cÓ*Ø÷ +ð
 ˆ�÷ +Õ*ûäó 	)Üœ#˜a›&“/ qÐ(ûð	)ús6   Á!
B Á+A=Á-B Á=
BÂB ÂB Â
B2ÂB-Â-B2c                 ó"   • U R                  5       $ )z�The default implementation will raise if a lock cannot be obtained.

Subclasses may override this method to provide a different implementation.
)r>  r\  s    r^   Ú_obtain_lockÚLockFile._obtain_lockƒ  s   € ð
 ×)Ñ)Ó+Ð+rd   c                 ó–   • U R                  5       (       d  gU R                  5       n [        U5        SU l        g! [         a     Nf = f)z Release our lock if we have one.NF)r5  r2  r™   r<  r)  )rk   Úlfps     r^   r.  ÚLockFile._release_lockŠ  sK   € à�~‰~×ÑØð ×"Ñ"Ó$ˆð	Ü�3ŒKð  ˆ�øô ó 	Ùð	ús   ¨; »
AÁAr‡  )rq   r‰  rŠ  r‹  rŒ  r’  rA   r]  r/  r‘   r2  rï   r5  r>  rA  r.  r–  rÚ   rd   r^   r   r   K  sM   † ñð -€Ið  (ð  ¨tô  ôð- ô -ð˜4ô ôô0,÷ rd   r   c            	       óp   ^ • \ rS rSrSrSrS\R                  4S\S\	S\
SS	4U 4S
 jjjrSU 4S jjrSrU =r$ )r   i™  a
  The lock file will block until a lock could be obtained, or fail after a
specified timeout.

:note:
    If the directory containing the lock was removed, an exception will be raised
    during the blocking period, preventing hangs as the lock can never be obtained.
)Ú_check_intervalÚ_max_block_timeg333333Ó?r*  Úcheck_interval_sÚmax_block_time_srL   Nc                 ó<   >• [         TU ]  U5        X l        X0l        g)zîConfigure the instance.

:param check_interval_s:
    Period of time to sleep until the lock is checked the next time.
    By default, it waits a nearly unlimited time.

:param max_block_time_s:
    Maximum amount of seconds we may lock.
N)r�  r]  rG  rH  )rk   r*  rI  rJ  rž  s       €r^   r]  ÚBlockingLockFile.__init__¤  s   ø€ ô 	‰Ñ˜Ô#Ø/ÔØ/Õrd   c                 ó,  >• [         R                   " 5       nU[        U R                  5      -   n  [        TU ]  5         g! [
         aÇ  n[         R                   " 5       n[        R                  " [        R                  " U R                  5       5      5      (       d#  SU R                  5       XA-
  4-  n[        U5      UeXB:¼  a#  SX!-
  U R                  5       4-  n[        U5      Ue[         R                  " U R                  5         SnAOSnAff = fMæ  )zÑThis method blocks until it obtained the lock, or raises :exc:`IOError` if it
ran out of time or if the parent directory was not available anymore.

If this method returns, you are guaranteed to own the lock.
zVDirectory containing the lockfile %r was not readable anymore after waiting %g secondsz Waited %g seconds for lock at %rN)Útimerr  rH  r�  rA  r:  r•   rÑ   rÐ   r2  ÚsleeprG  )rk   Ú	starttimeÚmaxtimerÊ   ÚcurtimeÚmsgrž  s         €r^   rA  ÚBlockingLockFile._obtain_lock·  sÿ   ø€ ô —I’I“Kˆ	Øœe D×$8Ñ$8Ó9Ñ9ˆØðÜ‘Ñ$Ô&ð, øô+ ó 1ô Ÿ)š)›+�Ü—y’y¤§¢¨T×-AÑ-AÓ-CÓ!D×EÑEØrØ×,Ñ,Ó.ØÑ+ðvñ �Cô " #›,¨AÐ-ð Ó%Ø<ØÑ+Ø×,Ñ,Ó.ð@ñ �Cô " #›,¨AÐ-ä—
’
˜4×/Ñ/×0Ñ0ûð'1úñ s   ±A  Á 
DÁ
B=DÄDr‡  )rq   r‰  rŠ  r‹  rŒ  r’  ra   ÚmaxsizerA   rr  r�  r]  rA  r–  r¢  r£  s   @r^   r   r   ™  sU   ø† ñð 7€Ið
 #&Ø #§¡ñ	0àð0ð  ð0ð ð	0ð
 
÷0ð 0÷& õ  rd   r   c                   óÈ   ^ • \ rS rSrSrSrSS\S\SS4U 4S jjjrSS\S\SS	4U 4S
 jjjrS\	S\
4S jrS\S\4S jrS\\\\\4   S\4S jrS\\\\\4   SS	4S jrSrU =r$ )r
   iÛ  an  List of iterable objects allowing to query an object by id or by named index::

 heads = repo.heads
 heads.master
 heads['master']
 heads[0]

Iterable parent objects:

* :class:`Commit <git.objects.Commit>`
* :class:`Submodule <git.objects.submodule.base.Submodule>`
* :class:`Reference <git.refs.reference.Reference>`
* :class:`FetchInfo <git.remote.FetchInfo>`
* :class:`PushInfo <git.remote.PushInfo>`

Iterable via inheritance:

* :class:`Head <git.refs.head.Head>`
* :class:`TagReference <git.refs.tag.TagReference>`
* :class:`RemoteReference <git.refs.remote.RemoteReference>`

This requires an ``id_attribute`` name to be set which will be queried from its
contained items to have a means for comparison.

A prefix can be specified which is to be used in case the id returned by the items
always contains a prefix that does not matter to the user, so it can be left out.
)Ú_id_attrÚ_prefixÚid_attrÚprefixrL   zIterableList[T_IterableObj]c                 ó"   >• [         TU ]  U 5      $ r±   )r�  Ú__new__)rÍ  rY  rZ  rž  s      €r^   r\  ÚIterableList.__new__ú  s   ø€ Ü‰w‰˜sÓ#Ð#rd   Nc                 ó:   >• [         TU ]  5         Xl        X l        g r±   )r�  r]  rW  rX  )rk   rY  rZ  rž  s      €r^   r]  ÚIterableList.__init__ý  s   ø€ Ü‰ÑÔØŒØ�rd   ré  c                 óÒ   •  [         R                  X5      nU(       a  U$   [	        U [        [        U5      5        g! [        [        4 a     N.f = f! [        [        4 a     gf = f)NTF)ÚlistÚ__contains__ÚAttributeErrorÚ	TypeErrorrç  r6   r‘   )rk   ré  Úrvals      r^   rb  ÚIterableList.__contains__  sm   € ð	Ü×$Ñ$ TÓ0ˆDÞØ�ð ð	Ü�Dœ$œs D›/Ô*Øøô ¤	Ð*ó 	Ùð	ûô ¤	Ð*ó 	Ùð	ús    ‚= ¢A ½AÁAÁA&Á%A&c                 ó–   • U R                   U-   nU  H   n[        X R                  5      U:X  d  M  Us  $    [        R	                  X5      $ r±   )rX  rç  rW  ra  Ú__getattribute__)rk   ré  Úitems      r^   Ú__getattr__ÚIterableList.__getattr__  sC   € Ø�|‰|˜dÑ"ˆÛˆDÜ�tŸ]™]Ó+¨tÕ3Ø’ñ ô ×$Ñ$ TÓ0Ð0rd   rL  c                 ó&  • [        U[        5      (       a  [        R                  X5      $ [        U[        5      (       a  [        S5      e [        U [        [        U5      5      $ ! [         a   n[        SU R                   U 35      UeS nAff = f)NzIndex should be an int or strzNo item found with id )r>  r�  ra  Ú__getitem__Úslicer¿   rç  r6   r‘   rc  Ú
IndexErrorrX  )rk   rL  rÊ   s      r^   rm  ÚIterableList.__getitem__  s…   € ô �eœS×!Ñ!Ü×#Ñ# DÓ0Ð0Ü˜œu×%Ñ%ÜÐ<Ó=Ð=ðXÜ˜t¤T¬#¨uÓ%5Ó6Ð6øÜ!ó XÜ Ð#9¸$¿,¹,¸ÈÀwÐ!OÓPÐVWÐWûðXús   ÁA& Á&
BÁ0BÂBc                 ó$  • [        [        U5      n[        U[        5      (       aV  SnU R                  U-   n[        U 5       H"  u  pE[        XPR                  5      U:X  d  M   Un  O   US:X  a  [        SU-  5      e[        R                  X5        g )NéÿÿÿÿzItem with name %s not found)r6   r�  r>  r‘   rX  rF  rç  rW  ro  ra  Ú__delitem__)rk   rL  ÚdelindexrJ   Úiri  s         r^   rs  ÚIterableList.__delitem__*  s�   € Üœ˜UÓ#ˆÜ�eœS×!Ñ!ØˆHØ—<‘< %Ñ'ˆDÜ$ Tž?‘�Ü˜4§¡Ó/°4Õ7Ø �HÙñ +ð ˜2‹~Ü Ð!>ÀÑ!EÓFÐFô 	×Ñ˜Õ(rd   )rN   )rq   r‰  rŠ  r‹  rŒ  r’  r‘   r\  r]  r•  rï   rb  rF   rj  r5   rC   r�  rn  rm  rs  r–  r¢  r£  s   @r^   r
   r
   Û  sÀ   ø† ñð8 (€Iñ$˜cð $¨3ð $Ð8U÷ $ð $ñ ð ¨Sð ¸$÷ ð ð
 ð ¨Dô ð$1 ð 1¨ô 1ðXØ˜=¨#¨u°cÐ9Ñ:ðXà	ôXð)  }°c¸5À#Ð'EÑ!Fð )È4÷ )ò )rd   r
   c                   ó†   • \ rS rSr% SrSr\\S'   \\	SSS\
S\
S	\\   4S
 j5       5       r\SSS\
S\
S	\\   4S j5       rSrg)r	   i<  a�  Defines an interface for iterable items, so there is a uniform way to retrieve
and iterate items within the git repository.

Subclasses:

* :class:`Submodule <git.objects.submodule.base.Submodule>`
* :class:`Commit <git.objects.Commit>`
* :class:`Reference <git.refs.reference.Reference>`
* :class:`PushInfo <git.remote.PushInfo>`
* :class:`FetchInfo <git.remote.FetchInfo>`
* :class:`Remote <git.remote.Remote>`
rÚ   Ú_id_attribute_ro   r<   rl   rm   rL   c                 ó   • [        S5      e)a#  Find (all) items of this type.

Subclasses can specify `args` and `kwargs` differently, and may use them for
filtering. However, when the method is called with no additional positional or
keyword arguments, subclasses are obliged to to yield all items.

:return:
    Iterator yielding Items
úTo be implemented by Subclass©ÚNotImplementedError©rÍ  ro   rl   rm   s       r^   Ú
iter_itemsÚIterableObj.iter_itemsO  s   € ô "Ð"AÓBÐBrd   c                 óz   • [        U R                  5      nUR                  U R                  " U/UQ70 UD65        U$ )aj  Find (all) items of this type and collect them into a list.

For more information about the arguments, see :meth:`iter_items`.

:note:
    Favor the :meth:`iter_items` method as it will avoid eagerly collecting all
    items. When there are many items, that can slow performance and increase
    memory usage.

:return:
    list(Item,...) list of item instances
©r
   rx  Úextendr~  ©rÍ  ro   rl   rm   Úout_lists        r^   Ú
list_itemsÚIterableObj.list_items^  s8   € ô 1=¸S×=OÑ=OÓ0PˆØ�‰˜Ÿš tÐ=¨dÒ=°fÑ=Ô>Øˆrd   N)rq   r‰  rŠ  r‹  rŒ  r’  r‘   rŽ  rû  r   r%   r,   rF   r~  r
   r…  r–  rÚ   rd   r^   r	   r	   <  s‹   ‡ ñð €IàÓàØðC˜fð C¨Sð C¸Cð CÀHÈ]ÑD[ó Có ó ðCð ð˜fð ¨Sð ¸Cð ÀLÐQ^ÑD_ó ó órd   r	   c                   óT   ^ • \ rS rSrSrS\S\\S4   S\\\	4   SS4U 4S	 jjr
S
rU =r$ )ÚIterableClassWatcheriq  z^Metaclass that issues :exc:`DeprecationWarning` when :class:`git.util.Iterable`
is subclassed.rJ   Úbases.ÚclsdictrL   Nc                 óœ   >• [         TU ]  XU5        U H5  n[        U5      [        L d  M  [        R
                  " SU S3[        SS9  M7     g )Nz!GitPython Iterable subclassed by zq. Iterable is deprecated due to naming clash since v3.1.18 and will be removed in 4.0.0. Use IterableObj instead.r©  rª  )r�  r]  Útyperˆ  r¬  r­  r®  )rÍ  rJ   r‰  rŠ  Úbaserž  s        €r^   r]  ÚIterableClassWatcher.__init__u  sN   ø€ Ü‰Ñ˜ gÔ.ÛˆDÜ�D‹zÔ1Ô1Ü—’Ø7¸°vð >0ð 0ô 'Ø ôò rd   rÚ   )rq   r‰  rŠ  r‹  rŒ  r‘   r1   rŒ  r)   r%   r]  r–  r¢  r£  s   @r^   rˆ  rˆ  q  s@   ø† ñð˜Cð ¨¨d°C¨iÑ(8ð À4ÈÈSÈÁ>ð ÐVZ÷ õ rd   rˆ  c            	       óh   • \ rS rSrSrSrSr\SSS\S\S	\4S
 j5       r	\SSS\S\S	\4S j5       r
Srg)ÚIterableiƒ  z«Deprecated, use :class:`IterableObj` instead.

Defines an interface for iterable items, so there is a uniform way to retrieve
and iterate items within the git repository.
rÚ   z5attribute that most suitably identifies your instancero   r<   rl   rm   rL   c                 ó   • [        S5      e)z®Deprecated, use :class:`IterableObj` instead.

Find (all) items of this type.

See :meth:`IterableObj.iter_items` for details on usage.

:return:
    Iterator yielding Items
rz  r{  r}  s       r^   r~  ÚIterable.iter_itemsŽ  s   € ô "Ð"AÓBÐBrd   c                 óz   • [        U R                  5      nUR                  U R                  " U/UQ70 UD65        U$ )zÙDeprecated, use :class:`IterableObj` instead.

Find (all) items of this type and collect them into a list.

See :meth:`IterableObj.list_items` for details on usage.

:return:
    list(Item,...) list of item instances
r�  rƒ  s        r^   r…  ÚIterable.list_items›  s8   € ô % S×%7Ñ%7Ó8ˆØ�‰˜Ÿš tÐ=¨dÒ=°fÑ=Ô>Øˆrd   N)rq   r‰  rŠ  r‹  rŒ  r’  rx  rû  r%   r~  r…  r–  rÚ   rd   r^   r�  r�  ƒ  sw   † ñð €IàL€Nàð
C˜fð 
C¨Sð 
C¸Cð 
CÀCó 
Có ð
Cð ð˜fð ¨Sð ¸Cð ÀCó ó órd   r�  )Ú	metaclass)i   )Fr±   )T).)…ra   Ú__all__rb   rð   Úabcr   Ú
contextlibÚ	functoolsr   r2  ÚloggingrU   Úos.pathr   r•   Úpathlibr   r“  r’   r†   r  rN  Úurllib.parser   r   r¬  Ú
gitdb.utilr   r   r   r   r    r!   r"   r#   r$   Útypingr%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   Úgit.cmdr8   Ú
git.configr9   r:   Ú
git.remoter;   Úgit.repo.baser<   Ú	git.typesr=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rI   Ú	getLoggerrq   rX   r‘   rï   r_   rc   r   re   rf   r   Úcontextmanagerrz   r~   r   r™   r�  r   r   r   r   r³   r   r»   rÌ   r   rß   rõ   rþ   r”  ÚIr  rŽ  rü   r  r  r  r(  r+  r   r8  r;  rS  r   r   r¥  r   r   r   r   r   r
   r	   rŒ  rˆ  r�  rÚ   rd   r^   Ú<module>r¨     s  ðô ò€ð* ‡<�<�7ÓØ‡N�NÐ+Ô,å Û Ý Û Û Û 	Ý Ý Û Û 	Û Û Û Û ß -Û ÷
÷ 
õ 
÷÷ ÷ ÷ ÷ ñ ö, Ýß=Ý!Ý"÷
÷ 
õ 
ñ ˜¨uÐ5VÑ/WÐcgÑh€á
�) 7Ñ
+€à
×
Ò
˜HÓ
%€ð˜ð  tð °ô ð4
E˜Sð 
E¨4ð 
E°Dô 
Eñ  /Ð/JÈDÓQÐ Ù/Ð0LÈdÓSÐ ñ ˆCƒL€ð�h˜s A˜vÑ&ð ¨8°C¸°FÑ+;ô ð$ ×Ñð�ð ˜i¨°$¸Ð(<Ñ=ó ó ðð ×Ñð
)�Cð 
) ð 
)¨	Ð2BÑ(Có 
)ó ð
)ð-�ð -˜dô -ðB�ð ˜dô ñ˜ð ¨xð ÀSð ÐZ]õ ð$�ð ˜xð ¨Hô ð$ ‡<�<�7Óð' Xð '°#ô 'ð' 8ð '°ô 'ð ,�Nð 8ð °ô ð *€Nð,˜ð , hð ,°8ô ,ðG˜(ð G tô Gð"*˜Hð *¨Hð *¸ô *ñZ (ð °Tð Àdõ ð&˜X c™]ô ñ#�cð # ¨(Ñ!3ð #¸tÀC¹yõ #ñL$�h˜s‘mð $¨3ð $¸Tð $ÈSõ $ð. 	�
Š
Ð@ÓAÙ	fØðð
 ‡Z‚ZÐ)Ó*¨Z¸%Ð@Ø‡Z‚ZÐ!Ó" Z°%Ð8Ø‡Z‚Z�˜bŸd™dÓ#Ñ&AÀDÐIØ‡Z‚Z�Ó¡/°EÐ:ðOÐ �%˜˜g c™l¨H°S¸#°XÑ,>ÀÐDÑEÀsÐJÑKó ñ�#ð  Dð °Cõ ð* —:’:Ð?Ó@Ð ð#�Hð # ô #ð /1Ð �$�s˜H T™NÐ*Ñ+Ó 0ð 3ð ¨4ô ð: 
Ø > $Ð >¨7°5©>Ó >ó 
Ø >ð 
Ø 8 (Ð 8¨tÓ 8ó 
Ø 8ð3 %¨¨h¨Ñ"7ð 3¸Dô 3ð:�Sô :ð
˜5Ð!MÑNð ÐZ]ð Ðbfô ð 
Ù >�4Ð > dÐ >°TÔ >ó 
Ø >ð 
ñ�8ð ¨$ð ¸À(Ñ9Kô ó 
ðñ
�5˜˜x˜Ñ(ð °tð ÀxÐPXÑGYõ ð#¨°©ð #¸$¸s¹)ô #÷Vzñ zôz(˜^ô (÷(ñ ÷}Yñ }Y÷@=1ñ =1÷@ ñ  ÷FK ñ K ô\>�xô >ôD^)�4˜Ñ&ô ^)ðB ô1�(ó 1ó ð1ôh˜4ô ô$%Ð-ó %rd   