.Ph fUddlZgdZejdkredddlmZddlZddlmZddl Z ddl Z ddl Z ddl m ZddlZddlZddlZddlZddlZddlZddlZddlmZmZddlZddlmZmZmZmZmZmZm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5e1rdd l6m7Z7dd l8m9Z9m:Z:dd l;mZ>ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHe2de3ddZIe jJeKZLdeMdeNdeNfdZOdeMdeNdeNfdZPePddZQePddZRe2dZSde'deSfde'deSffdZTejUdeDde)eDddffdZVejUdeMd eMde)d!fd"ZWd#eDddfd$ZXd#eDddfd%ZYdnd'e&d(e&d)eZdeZfd*Z[d+eDd,eDdeDfd-Z\ejdkrd#eDdeDfd.Z]d#eDdeMfd/Z^e]Z_n d#eDdeMfd0Z^e^Z_d+eDd,eDdeDfd1Z`dod#eDd3eNdeNfd4Zade/eMfd5Zbdpd6eMd#e-eDde,eMfd7Zcd8e-eMd#eMdeMfd9Zdejed:d;d2fejed<edd2fejed=edd2fejed>ejfd?dfejed@dAd2ffZge0e0e.eMe'eNfdfehdB<d#eMdeMfdCZiejedDZjd#eDdeMfdEZkiZle(eMe-eNfehdF<dGeMdeNfdHZme5dGddeCd2fdIZne5dGeDdeNfdJZndGe3deDfdeNfdKZndeMfdLZodMe3ejpdNfdOe$ddfdPZqe5dqd,ddQeNddfdRZre5dqd,eDdQeNdeMfdSZrdrd,e3deDfdQeNde-eDfdTZrdUe/eMde,eMfdVZsGdWdXZtGdYdZetZuGd[d\ZvGd]d^ZwGd_d`ZxGdadbZyGdcddeyZzGdedfe,eIZ{eHGdgdheEZ|Gdidje}Z~Gdkdle~mZdS)sN) stream_copy join_pathto_native_path_linuxjoin_path_nativeStatsIndexFileSHA1Writer IterableObj IterableListBlockingLockFileLockFileActor get_user_idassure_directory_existsRemoteProgressCallableRemoteProgressrmtree unbare_repoHIDE_WINDOWS_KNOWN_ERRORSwin32to_native_path_windows)abstractmethod)wraps)urlsplit urlunsplit) LazyMixinLockedFD bin_to_hexfile_contents_rofile_contents_ro_filepath hex_to_binmake_sha to_bin_sha to_hex_sha)AnyAnyStrBinaryIOCallableDict GeneratorIOIteratorListOptionalPatternSequenceTuple TYPE_CHECKINGTypeVarUnioncastoverload)Git)GitConfigParserSectionConstraint)Remote)Repo) Files_TDHas_id_attributeHSH_TDLiteralPathLikeProtocol SupportsIndexTotal_TDruntime_checkable T_IterableObj)r r<T)bound covariantnamedefaultreturnc& tj|}n#t$r|cYSwxYwtd||}|dvrdS|dvrdStd||||S)zRead 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.>0nofalseF>1yestrueTz-%s has unrecognized value %r, treating as %r.)osenvironKeyError_loggerwarningstriplower)rGrHvalueadjusted_values H/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/git/util.py_read_env_flagr\ss  4   OOv  [[]]((**N111u---t OOCT5RYZZZ Ns  $$cBtjdkot||S)aRead 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)sysplatformr\)rGrHs r[_read_win_env_flagr`s  <7 " D~dG'D'DDrHIDE_WINDOWS_FREEZE_ERRORSTfunc.c |ddlmtdddtdtdtffd }|S) ztMethods with this decorator raise :exc:`~git.exc.InvalidGitRepositoryError` if they encounter a bare repository.)InvalidGitRepositoryErrorselfr9argskwargsrIcZ|jjrdjz|g|Ri|S)Nz/Method '%s' cannot operate on bare repositories)repobare__name__)rhrirjrgrds r[wrapperzunbare_repo..wrappersK 9> o++,]`d`m,mnn ntD*4***6***ra)excrgrr$rc)rdrorgs` @r[rrsn/..... 4[[+h+s+c+a++++++[+ Nranew_dirc#Ktj}tj| |Vtj|dS#tj|wxYw)zContext 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)rRgetcwdchdir)rqold_dirs r[cwdrvs]ikkGHW  s AArY)NNNc#Ktj|}|tj|< dV|tj|=dS|tj|<dS#|tj|=n|tj|<wxYw)z=Context manager to temporarily patch an environment variable.N)rRgetenvrS)rGrY old_values r[ patch_envrzs $IBJt)    4   (BJt      4  (BJt  ( ( ( (s A !A.pathcdtdtdtddfd}tjdkrt j|dStjdkrt j|| dSt j|| dS) zRemove 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{_excinforINctj|tj ||dS#t$r"}t rddlm}|d||d}~wwxYw)zuCallback for :func:`shutil.rmtree`. This works as either a ``onexc`` or ``onerror`` style callback. r)SkipTestz%FIXME: fails with: PermissionError N)rRchmodstatS_IWUSRPermissionErrorrunittestr)r}r{r~exrs r[handlerzrmtree..handlers t|$$$  HTNNNNN   ( V------hLLLMMSUU   s . AAAr) )onexc)onerror)r'r?r$r^r_shutilr version_info)r{rs r[rrs((cd" |w d W $ $ d'****** dG,,,,,,ractj|r;tjdkrt j|dt j|dSdS)zWEnsure file deleted also on *Windows* where read-only files need special treatment.riN)ospisfiler^r_rRrremover{s r[rmfilersP z$ <7 " " HT5 ! ! ! $rasource destination chunk_sizecd} ||}|||t|z }t||krnQ|S)zCopy all data from the `source` stream into the `destination` stream in chunks of size `chunk_size`. :return: Number of bytes written r)readwritelen)rrrbrchunks r[rrsc B J''%    c%jj u:: " "   Iraapct|}|D]`}t|}|s|dr||ddz }7|dks|dr||z }X|d|zz }a|S)zmJoin path tokens together similar to osp.join, but always use ``/`` instead of possibly ``\`` on Windows./rfNrK)str startswithendswith)rrr{bs r[rrs q66D    FF   <<    AabbEMDD RZZ4==--Z AIDD C!GODD KracLt|}|ddS)Nr\rreplacers r[rr$s!4yy||C&&&racLt|}|ddS)Nrrrrs r[rr(s!4yy||D#&&&rac t|SN)rrs r[rr/s4yyrac6tt|g|RS)zLike :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)rrs r[rr5s" )A**** + ++raFis_filec|rtj|}tj|stj|ddSdS)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)rdirnameisdirrRmakedirs)r{rs r[rr>sJ!{4   9T?? D4((((t 5ractjdd}|r6td|tjDSt jdkrdSdS)NPATHEXTc3>K|]}|VdSr)upper).0rs r[ z&_get_exe_extensions..Ts*BB1QWWYYBBBBBBrar)z.BATz.COMz.EXE)rRrSgettuplesplitpathsepr^r_)rs r[_get_exe_extensionsrQsbjnnY--GBB bj(A(ABBBBBB  ''rraprogramctdtdtffd }g}|stjd}t|tjD]c}|d}|rJtj ||gfdDzD]"}||r| |#d|S)a6Perform 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. fpathrIctjoLtjtjo-t jdkp ptfdDS)Nrc3fK|]+}|V,dSr)rr)rextrs r[rz,py_where..is_exec..ps;BwBwcf5;;==CYCYZ]C^C^BwBwBwBwBwBwra)rrrRaccessX_OKr^r_any)r winprog_extss`r[is_execzpy_where..is_execksh Ju    %))  'w|+;wsBwBwBwBwjvBwBwBw?w?w  raPATH"cg|]}| Srr)reexe_paths r[ zpy_where..{s""P"P"PaXXqq#9"P"P"Pra) rrboolrRrSrrrWrjoinappend)rr{rprogsfolderfrrs @@r[py_wherer[s'((L s t       E "z&!d))//"*--$$c""  $x00HZ"P"P"P"P<"P"P"PP $ $71::$LLOOO Lradrivec|tj|r|s|}n|o7tjtjtj|}tj|r|r|}n,t |}n|rd|d|}t|}|ddS)Nz/proc/cygdrive/rr) risabsnormpath expandvars expandusercygpathrXrr)rr{rp_strs r[ _cygexpathrs y rs,&&&%%%IZIZ[_adIeIeIe*fraz\\\\\?\\(\w):[/\\](.*)z(\w):[/\\](.*)z file:(.*)c|Srr)rs r[rrs raz (\w{2,}:.*)c|Srr)urls r[rrscra_cygpath_parsersc t|}|ds_tD]G\}}}||}|r*||}|rt |}nHt d|}|S)zJUse :meth:`git.cmd.Git.polish_url` instead, that works on any environment.)z /cygdriverz/proc/cygdriveN)rrrmatchgroupsrr)r{regexparserrecursers r[rrs t99D ??@ A A *&6 * * "E67KK%%E vu||~~.)"4==D   dD))D Kraz(?:/proc)?/cygdrive/(\w)(/.*)?ct|}t|}|r2|\}}|d|pd}|ddS)N:rKrr)r_decygpath_regexrrrr)r{mrrs r[ decygpathrsj t99Dt$$A:88::y++----b9 <<T " ""ra_is_cygwin_cachegit_executablect|}|d} tj|}|s-t |}|rtj|dnd}tj|d}t j|gt jd}| \}}d|v}n2#t$r%}t d|Yd}~nd}~wwxYw|t|<|S) NFrrKunameT)stdoutuniversal_newlinesCYGWINz/Failed checking if running in CYGWIN due to: %r) rrrrrr subprocessPopenPIPE communicate ExceptionrUdebug) r is_cygwingit_dirres uname_cmdprocess uname_out_rs r[_is_cygwin_gitr s $$^44I  Qk.11G =~..14<#+c!f---"'22I & {:?_cdddG"..00LIq I-II Q Q Q MMKR P P P P P P P P Q+4( sBB66 C%C  C%cdSrrrs r[ is_cygwin_gitr;>3racdSrrr s r[rrs58SracftjdkrdS|dStt|S)NrF)r^r_r rr s r[rrs5 |wu  uc.11222racTtjdtjS)zM:return: String identifying the currently active system user as ``name@node``@)getpassgetuserr_noderrar[rrs#o'''' 99raproczGit.AutoInterruptrjc |jdi|dS)zXWait for the process (clone, fetch, pull or push) and handle its errors accordingly.Nr)wait)rrjs r[finalize_processrs"DIra expand_varscdSrrrrs r[ expand_pathrrracdSrrrs r[rrs Crac"t|tjr|S t j|}|rt j|}t jt j|S#t$rYdSwxYwr) isinstancepathlibPathresolverrrrabspathrrs r[rrs!W\""yy{{ N1    "q!!A|CKNN+++ ttsAB B Bcmdlinecg}t|D]\}}|| t|}|j|j9|j4||j|jd}|j4||j|jd}t|||<#t$rYwxYw|S)a>Parse any command line argument and if one of the elements is an URL with a username and/or password, replace them by stars (in-place). 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. Nz*****)netloc) enumeraterrpasswordusername_replacer(rr ValueError)r& new_cmdlineindexto_parsers r[remove_password_if_presentr1sK$W--x8$$$ 8$$C|# (<|'ll#**<*Cs...Aa...razdone.z, ) _cur_line _seen_ops error_lines other_linesz%(remote: )?([\w\s]+):\s+()(\d+)()(.*)z2(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)rINc>g|_d|_g|_g|_dSr)r8r7r9r:rhs r[__init__zRemoteProgress.__init__Ss&$&(,&(&(ralinect|tr|d}n|}||_|jdr!|j|jdSd\}}|j|}||j |}|s1| ||j |dSd}| \}}} }}} |dkr ||j z}n}|dkr ||jz}nl|dkr ||jz}n[|d kr ||jz}nJ|d kr ||jz}n9|d kr ||jz}n(|d kr ||jz}n| |dS||jvr$|j|||jz}| d } | } | |jr'||jz}| dt5|j } | |j} |||ot;||ot;|| dS)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`. zutf-8)zerror:zfatal:N)NNrzCounting objectszCompressing objectszWriting objectszReceiving objectszResolving deltaszFinding sourceszChecking out filesrK)r!bytesdecoder7rr9rre_op_relativerre_op_absolute line_droppedr:rCOUNTING COMPRESSINGWRITING RECEIVING RESOLVINGFINDING_SOURCES CHECKING_OUTr8BEGINrWr DONE_TOKENENDrTOKEN_SEPARATORupdatefloat) rhr>line_str cur_count max_countrop_code_remoteop_name_percentmessages r[_parse_progress_linez#RemoteProgress._parse_progress_lineYs dE " " {{7++HHH! > $ $%9 : :    # #DN 3 3 3 F) 9#))(33 ='--h77E    h ' ' '   # #H - - - FDILLNNA(Iy' ( ( ( t} $GG - - - t' 'GG ) ) ) t| #GG + + + t~ %GG * * * t~ %GG ) ) ) t+ +GG , , , t( (GG   h ' ' ' F $. ( ( N ! !' * * * tz !G ?G--//   DO , , 7 tx G5T_!5!5 556G-- 455   *% **  *% **       rac&dtddffd }|S)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>rINcR|Sr)rZrstrip)r>rhs r[rz3RemoteProgress.new_message_handler..handlers,,T[[]];; ;ra)r%)rhrs` r[new_message_handlerz"RemoteProgress.new_message_handlers6 <& s r[rDzRemoteProgress.line_droppeds rarKrUrSrTrYcdS)aCalled 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)rhrUrSrTrYs r[rPzRemoteProgress.updates H rarINNrK)$rn __module__ __qualname____doc__r4int__annotations__rangerLrNrErFrGrHrIrJrK STAGE_MASKOP_MASKrMrO __slots__recompilerCrBr=r%rZr'rr^rDr3rQrPrrar[rr3s55M3 /.}--...   JkGJOI  RZ HIINRZ UVVN)))) W W DW W W W r XseTk%:          .2 $ $ $ e$$ eT)* $  $  $ $ $ $ $ $ rarcDeZdZdZdZdeddffd Zdededdfd ZxZ S) raA :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`.  _callablefnrINcV||_tdSr)rpsuperr=)rhrq __class__s r[r=zCallableRemoteProgress.__init__s& rarirjc |j|i|dSrro)rhrirjs r[rPzCallableRemoteProgress.updates''''''ra) rnrcrdrerkr'r=r$rP __classcell__rts@r[rrsI8(C(3(4((((((((rarc eZdZdZejdZejdZdZdZ dZ dZ dZ d Z d Zdeed eed d fd Zded efdZded efdZd efdZd efdZd efdZeded dfdZe ddedededd dfdZeddedd dfdZeddedd dfdZd S)r zActors 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.z<(.*)>z (.*) <(.*?)>GIT_AUTHOR_NAMEGIT_AUTHOR_EMAILGIT_COMMITTER_NAMEGIT_COMMITTER_EMAILrGemailrGr}rINc"||_||_dSrr~)rhrGr}s r[r=zActor.__init__s  raothercB|j|jko|j|jkSrr~rhrs r[__eq__z Actor.__eq__syEJ&D4:+DDrac||k Srrrs r[__ne__z Actor.__ne__sEM""rac8t|j|jfSr)hashrGr}r<s r[__hash__zActor.__hash__sTY +,,,rac"|jr|jndSrb)rGr<s r[__str__z Actor.__str__"s I-tyy2-rac(d|jd|jdS)Nz ">r~r<s r[__repr__zActor.__repr__%s*.)))TZZZ@@rastringc&|j|}|r'|\}}t||S|j|}|r#t|ddSt|dS)zCreate an :class:`Actor` from a string. :param string: The string, which is expected to be in regular git format:: John Doe :return: :class:`Actor` rfN)name_email_regexsearchrr name_only_regexgroup)clsrrrGr}s r[ _from_stringzActor._from_string(s  ' ' / /  '((**KD%u%% %#**622A /QWWQZZ...&& &raenv_name env_email config_reader)Nr7r8c tdd}d dtf fd dtf fd }d||j|fd||j ffD]\}}}} tj|} t ||| ,#t$rq|C |d|} n#t$r | } YnwxYwt ||| t||st ||| YwxYw|S)NrKrIc(stSr)r)user_idsr[ default_emailz(Actor._main_actor..default_emailKs (%--NracJddS)Nrr)r)rsr[ default_namez'Actor._main_actor..default_nameQs" =??((--a0 0rarGr}user) r r conf_name conf_emailrRrSsetattrrTrrgetattr) rrrractorrattrevarcvarrHvalrrs @@r[ _main_actorzActor._main_actorAslb"  s        1c 1 1 1 1 1 1Xs}l ; i ?*  4 4 %D$g 4j&tS)))) 4 4 4 ,(+//==$(((%gii(E4---ud++4E4333 4 s6 #A11 C,>BC,B,)C,+B,,=C,+C,cD||j|j|S)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. )renv_committer_nameenv_committer_emailrrs r[ committerzActor.committeris!s5s7NP]^^^racD||j|j|S)zSame as :meth:`committer`, but defines the main author. It may be specified in the environment, but defaults to the committer.)renv_author_nameenv_author_emailrs r[authorz Actor.authorxs s2C4H-XXXrar) rnrcrdrerlrmrrrrrrrrrkr-rr=r$rrrrfrrr classmethodrr3rrrrrar[r r sI !bj++O!rz/22(O)-/IJ!IXc]8C=TECEDEEEE#C#D####-#----.....A#AAAA'#'''''['0 NR %%%%IJ %  %%%[%N _ _e,X&Y _el _ _ _[ _YY5)U#VYbiYYY[YYYrar c^eZdZdZdZdedeeefddfdZ e dd d e ddfd Z dS) raRepresents 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 totalfilesrrrINc"||_||_dSrr)rhrrs r[r=zStats.__init__s  rarlr:textcdddddid}|D]}|d\}}}}|dkrt|pd} |dkrt|pd} |ddxx| z cc<|ddxx| z cc<|dd xx| | zz cc<|dd xxd z cc<| | | | z|d } | |d |<t |d|d S) zCreate a :class:`Stats` object from output retrieved by :manpage:`git-diff(1)`. :return: :class:`git.Stats` r) insertions deletionslinesrr -rrrrrrf)rrr change_type) splitlinesrrfrWr) rrlrhshr>rraw_insertions raw_deletionsfilenamerr files_dicts r[_list_from_stringzStats._list_from_stringsg%&AANN  OO%% 8 8DEIZZPTEUEU B[.-'3.F3~3F3FK!J%,C]1C1CHqI L & & &* 4 & & & L % % % 2 % % % L ! ! !Z)%; ; ! ! ! L ! ! !Q & ! ! !(&#i/* $$J .8CL)) * *S\3w<000ra) rnrcrdrerkrBr(r?r;r=rrrrrar[rrs4#IhtHh4F/GD1V1317111[111rarcZeZdZdZdZdeddfdZdedefdZ de fd Z de fd Z defd Z dS) raWrapper 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. )rsha1rrINc<||_td|_dS)Nra)rr!r)rhrs r[r=zIndexFileSHA1Writer.__init__sSMM radatacj|j||j|Sr)rrPrr)rhrs r[rzIndexFileSHA1Writer.writes, v||D!!!racl|j}|j||Sr)rdigestrrrhshas r[ write_shazIndexFileSHA1Writer.write_shas.i    S rac`|}|j|Sr)rrclosers r[rzIndexFileSHA1Writer.closes%nn   rac4|jSr)rtellr<s r[rzIndexFileSHA1Writer.tellsv{{}}ra)rnrcrdrerkr*r=r%rfrr@rrrrrar[rrsI""""""""&"S""""5 u crarc^eZdZdZdZdeddfdZd dZdefdZ de fd Z d d Z d d Z d d ZdS)r aProvides 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_pathrINc"||_d|_dS)NFr)rhrs r[r=zLockFile.__init__s#rac.|dSr) _release_lockr<s r[__del__zLockFile.__del__s racd|jzS)z:return: Path to lockfilez%s.lock)rr<s r[_lock_file_pathzLockFile._lock_file_pathsDO,,rac|jS)z :return: True if we have a lock and if the lockfile still exists :raise AssertionError: If our lock-file does not exist. )rr<s r[ _has_lockzLockFile._has_locks rac||rdS|}tj|rt d|jd|d t |d5 dddn #1swxYwYn/#t$r"}t t||d}~wwxYwd|_ dS)zCreate 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. NzLock for file z did already exist, delete z in case the lock is illegalw)modeT) rrrrIOErrorropenOSErrorrr)rh lock_filers r[_obtain_lock_or_raisezLockFile._obtain_lock_or_raises >>    F((** :i  '???III/   )ic***                  ) ) )#a&&//q ( )s<B,A:. B:A>>BA>B B2B--B2c*|S)zThe default implementation will raise if a lock cannot be obtained. Subclasses may override this method to provide a different implementation. )rr<s r[ _obtain_lockzLockFile._obtain_locks ))+++rac|sdS|} t|n#t$rYnwxYwd|_dS)z Release our lock if we have one.NF)rrrrr)rhlfps r[rzLockFile._release_lock!si~~  F""$$  3KKKK    D s< A A ra)rnrcrdrerkr?r=rrrrrrrrrrar[r r s-I ( t    -----40,,,,       rar c TeZdZdZdZdejfdedede ddffd Z d fd Z xZ S) r aThe 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?rcheck_interval_smax_block_time_srINcft|||_||_dS)aConfigure 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)rsr=rr)rhrrrrts r[r=zBlockingLockFile.__init__;s3 ###//racTtj}|t|jz} tdS#t $r}tj}t jt j| s,d| ||z fz}t ||||kr,d||z | fz}t ||tj |j Yd}~nd}~wwxYw)zThis 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. TzVDirectory containing the lockfile %r was not readable anymore after waiting %g secondsz Waited %g seconds for lock at %rN) timerQrrsrrrrrrsleepr)rh starttimemaxtimercurtimemsgrts r[rzBlockingLockFile._obtain_lockNsD IKK eD$8999  $$&&&,+ 1 1 1)++yT-A-A-C-C!D!DEE.r,,..)+vC"#,,A-g%%<)+,,..@C"#,,A- 4/00000000' 1 s A D&CD!!D&ra) rnrcrdrerkr^maxsizer?rQrfr=rrvrws@r[r r 0s7I #& # 000 0 0  000000&          rar ceZdZdZdZddededdffd Zddededd fd Zd ede fd Z d ede fd Z de eeeefde fdZde eeeefdd fdZxZS)r aList 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 ` * :class:`Submodule ` * :class:`Reference ` * :class:`FetchInfo ` * :class:`PushInfo ` Iterable via inheritance: * :class:`Head ` * :class:`TagReference ` * :class:`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_prefixrKid_attrprefixrIzIterableList[T_IterableObj]cFt|Sr)rs__new__)rrrrts r[rzIterableList.__new__swws###raNc"||_||_dSrr)rhrrs r[r=zIterableList.__init__s  rarc t||}|r|Sn#ttf$rYnwxYw t |t t |dS#ttf$rYdSwxYw)NTF)list __contains__AttributeError TypeErrorrr4r)rhrrvals r[rzIterableList.__contains__s $$T400D    *    D    D$sD// * * *4 *   55 s"66#AA43A4c|j|z}|D]}t||j|kr|cS t||Sr)rrrr__getattribute__)rhritems r[ __getattr__zIterableList.__getattr__sZ|d"  DtT]++t33 4$$T4000rar/c~t|tttfs Jdt|trt||St|trt d t||S#t$r }td|j |zz|d}~wwxYw)N-Index of IterableList should be an int or strzIndex should be an int or strzNo item found with id %r) r!rfrslicer __getitem__r-rr IndexErrorr)rhr/rs r[rzIterableList.__getitem__s%#sE!233dd5dddd eS ! ! ]##D%00 0 u % % ]<== = ]tU+++! ] ] ] !;t|e?S!TUU[\\ ]sB B<B77B<ct|ttfs Jdtt|}t|tsVd}|j|z}t |D]"\}}t ||j|kr|}n#|dkrtd|zt ||dS)NrzItem with name %s not found) r!rfrr4rr)rrrr __delitem__)rhr/delindexrGir s r[rzIterableList.__delitem__s%#s,,]].]]]]U##%%% GH<%'D$T??  44//477 HE8 2~~ !>!EFFF x(((((ra)rK)rnrcrdrerkrrr=objectrrrDrr3rArfrrrrvrws@r[r r rsA8(I$$c$3$8U$$$$$$S$D$11 1111 ]}c5#'E!F ]= ] ] ] ])}c5#'E!F)4))))))))rar c eZdZUdZdZeed<eeddde de de e fd Z eddde de de e fd Zd S) r aDefines an interface for iterable items, so there is a uniform way to retrieve and iterate items within the git repository. Subclasses: * :class:`Submodule ` * :class:`Commit ` * :class:`Reference ` * :class:`PushInfo ` * :class:`FetchInfo ` * :class:`Remote ` r_id_attribute_rlr:rirjrIc td)aSFind (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 SubclassNotImplementedErrorrrlrirjs r[ iter_itemszIterableObj.iter_itemss""ABBBracvt|j}||j|g|Ri||S)aFind (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 rextendr!rrlrirjout_lists r[ list_itemszIterableObj.list_itemssG".c.@!A!At=d===f==>>>raN)rnrcrdrerkrrgrrr$r+rDr!r r'rrar[r r s  I Cf CS CC CH]D[ C C C^[ CfSCLQ^D_[rar c*eZdZdZdedededdfdZdS)IterableClassWatcherzbMetaclass that issues :exc:`DeprecationWarning` when :class:`git.util.Iterable` is subclassed.rGbasesclsdictrINc||D]8}t|tur tjd|dtd9dS)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.) stacklevel)typer)warningswarnDeprecationWarning)rrGr*r+bases r[r=zIterableClassWatcher.__init__ se  DDzz111 0000'   ra)rnrcrdrerr0r(r=rrar[r)r) sN C         rar)c jeZdZdZdZdZedddededefd Zedddededefd Z d S) IterablezDeprecated, 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. rz5attribute that most suitably identifies your instancerlr:rirjrIc td)zDeprecated, use :class:`IterableObj` instead. Find (all) items of this type. See :meth:`IterableObj.iter_items` for details on usage. :return: Iterator yielding Items rrr s r[r!zIterable.iter_items%s""ABBBracvt|j}||j|g|Ri||S)aDeprecated, 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'zIterable.list_items2sG%S%788t=d===f==>>>raN) rnrcrdrerkrrr$r!r'rrar[r5r5s ILN Cf CS CC CC C C C[ C f S C C   [   rar5) metaclass)r)Fr).)T)r^__all__r_rabcr contextlib functoolsrrloggingrRos.pathr{rr"rlrrrr urllib.parserrr0 gitdb.utilrrrrrr r!r"r#typingr$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5git.cmdr6 git.configr7r8 git.remoter9 git.repo.baser: git.typesr;r<r=r>r?r@rArBrCrD getLoggerrnrUrrr\r`rrbrcrcontextmanagerrvrzrrrfrrrrrrrrrrrmIrrgrrrrr rrrrrr1rrr rrr r r r r/r)r5rrar[rJsz      *<7 NN+,,,   --------                      *#========!!!!!!""""""                      u5V/Wcghhh  ' H % %t4 ES E4 ED E E E E /./JDQQ//0LdSS GCLLhsAv&8CF+;$   i$(<=      )C ) ) 2B(C ) ) ) )--d----BdxSZ]$xH$<7'X'('''''8''''',NN8*N,,h,8,,,,(Td&Xc]##c#(!3#tCy####L$hsm$3$3$$$$.  @AA f f  RZ)**Z%@RZ!""Z%8RZ bd##&A&ADIRZ//E: E%gclHd:;S@A   ##$2:?@@#H#####/1$sHTN*+00034. >$>75>>>> > 8(8t888 83%h"73D3333:S:::: 5!13F!FGSV[_ >>4>d>T>>> > 8$   5x( t xPXGY     $s)Du u u u u u u u p(((((^((((}Y}Y}Y}Y}Y}Y}Y}Y@=1=1=1=1=1=1=1=1@        FK K K K K K K K \>>>>>x>>>D_)_)_)_)_)4 &_)_)_)D11111(111h4"%%%%%-%%%%%%ra