o ﯪg@s UddlmZddgZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z m Z ddlZddlmZddlZddlZddlmZmZmZddlmZmZmZmZmZdd lmZmZm Z m!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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5dd l6m7Z7m8Z8m9Z9e0rdd l:m;Z;dd le?e@ZA   dJdKddZBd eCd!<ejDd"krd#dd$dLd-d.ZEeEZFne ZFdMd1d2ZGdNdOd9d:ZHdNdPd?d@ZIdAZJdBZKdQdDdEZLGdFdGdGeMZNeNZO GdHddeNdIZPdS)R) annotationsGitMetaGitN)DEVNULLPIPEPopen)dedent)defenc force_bytes safe_decode) CommandErrorGitCommandErrorGitCommandNotFoundUnsafeOptionErrorUnsafeProtocolError)cygpath expand_path is_cygwin_git patch_envremove_password_if_present stream_copy)AnyAnyStrBinaryIOCallableDictIOIteratorListMappingOptionalSequence TYPE_CHECKINGTextIOTupleUnioncastoverload)LiteralPathLikeTBD) DiffIndex)Repo> envshellistream as_process with_stdout output_streammax_chunk_sizewith_exceptionsstdout_as_stringkill_after_timeoutuniversal_newlineswith_extended_outputstrip_newline_in_stdoutTprocess'Git.AutoInterrupt' | Popenstdout_handlersUnion[None, Callable[[AnyStr], None], Callable[[List[AnyStr]], None], Callable[[bytes, 'Repo', 'DiffIndex'], None]]stderr_handlerEUnion[None, Callable[[AnyStr], None], Callable[[List[AnyStr]], None]] finalizer@Union[None, Callable[[Union[Popen, 'Git.AutoInterrupt']], None]]decode_streamsboolr6Union[None, float]returnNonecCsdd d}t|dr)td|}t|jdd}|jr|jjnd}|jr&|jjnd} ntt|}t|dd}|j}|j} t|tt fsE| }g} |rQ| d||f| r[| d| |fg} | D]\} } }t j ||| | ||fd}d|_|| |q_| D];}|j|d|rt|tjr|ntd|d|rd|d}|st| trtt|}|}||q|r||dSdS)aRegister for notifications to learn that process output is ready to read, and dispatch lines to the respective line handlers. This function returns once the finalizer returns. :param process: :class:`subprocess.Popen` instance. :param stdout_handler: f(stdout_line_string), or ``None``. :param stderr_handler: f(stderr_line_string), or ``None``. :param finalizer: f(proc) - wait for proc to finish. :param decode_streams: Assume stdout/stderr streams are binary and decode them before pushing their contents to handlers. This defaults to ``True``. Set it to ``False`` if: - ``universal_newlines == True``, as then streams are in text mode, or - decoding must happen later, such as for :class:`~git.diff.Diff`\s. :param kill_after_timeout: :class:`float` or ``None``, Default = ``None`` To specify a timeout in seconds for the git command, after which the process should be killed. cmdline List[str]namestrstreamUnion[BinaryIO, TextIO] is_decoderChandler0Union[None, Callable[[Union[bytes, str]], None]]rErFc Sszfz |D]}|r|rt|tsJ|t}||q||qWn7tyX}z+td|dt|d|dt|vrNt d|dgt|||WYd}~n d}~wwW| dSW| dS| w)NzPumping z of cmd(z) failed due to: zI/O operation on closed file) isinstancebytesdecoder Exception_loggererrorrrJr close)rGrIrKrMrNlineline_strexr[C/var/www/html/chatdoc2/venv/lib/python3.10/site-packages/git/cmd.py pump_streams*      z*handle_process_output..pump_streamprocGit.AutoInterruptargsNstdoutstderr)targetr`T)timeoutzKThread join() timed out in cmd.handle_process_output(). kill_after_timeout=z secondsz?error: process killed because it timed out. kill_after_timeout=) rGrHrIrJrKrLrMrCrNrOrErF)hasattrr&getattrr^rbrcrrQtuplelistsplitappend threadingThreaddaemonstartjoinis_aliver AutoInterrupt _terminate RuntimeErrorrrJencode)r:r<r>r@rBr6r]rGp_stdoutp_stderrpumpsthreadsrIrKrNt error_strr[r[r\handle_process_outputasX /           r|zCallable[..., Popen] safer_popenwin32F)r.r-commandUnion[str, Sequence[Any]]r.r-Optional[Mapping[str, str]]kwargsrrcKsrtjtjB}|r|durint|}d|d<tddt|f|||d|WdS1s2wYdS)aCall :class:`subprocess.Popen` on Windows but don't include a CWD in the search. This avoids an untrusted search path condition where a file like ``git.exe`` in a malicious repository would be run when GitPython operates on the repository. The process using GitPython may have an untrusted repository's working tree as its current working directory. Some operations may temporarily change to that directory before running a subprocess. In addition, while by default GitPython does not run external commands with a shell, it can be made to do so, in which case the CWD of the subprocess, which GitPython usually sets to a repository working tree, can itself be searched automatically by the shell. This wrapper covers all those cases. :note: This currently works by setting the :envvar:`NoDefaultCurrentDirectoryInExePath` environment variable during subprocess creation. It also takes care of passing Windows-specific process creation flags, but that is unrelated to path search. :note: The current implementation contains a race condition on :attr:`os.environ`. GitPython isn't thread-safe, but a program using it on one thread should ideally be able to mutate :attr:`os.environ` on another, without unpredictable results. See comments in: https://github.com/gitpython-developers/GitPython/pull/1650 N1"NoDefaultCurrentDirectoryInExePath)r.r- creationflags) subprocessCREATE_NO_WINDOWCREATE_NEW_PROCESS_GROUPdictrr)rr.r-rrr[r[r\_safer_popen_windowss $ $rstringrJcCs |ddS)N_-)replace)rr[r[r\dashify& rr[self'Git'exclude Sequence[str]Dict[str, Any]csfddjDS)Ncs i|] }|vr|t|qSr[)rg).0srrr[r\ +s z!slots_to_dict..) __slots__)rrr[rr\ slots_to_dict*srobjectdMapping[str, Any]excludedcCs8|D] \}}t|||q|D]}t||dqdSN)itemssetattr)rrrkvr[r[r\$dict_to_slots_and__excluded_are_none.s rzuGit.USE_SHELL is deprecated, because only its default value of False is safe. It will be removed in a future release.aSetting Git.USE_SHELL to True is unsafe and insecure, as the effect of special shell syntax cannot usually be accounted for. This can result in a command injection vulnerability and arbitrary code execution. Git.USE_SHELL is deprecated and will be removed in a future release. extra_dangercCstj|rtnttdddS)N) stacklevel)warningswarn_USE_SHELL_DANGER_MESSAGE_USE_SHELL_DEFAULT_MESSAGEDeprecationWarning)rr[r[r\_warn_use_shellDs   rcsDeZdZdZd fdd Zd fd d ZeseZeZZ SZ S) _GitMetaztMetaclass for :class:`Git`. This helps issue :class:`DeprecationWarning` if :attr:`Git.USE_SHELL` is used. rIrJrErc|dkrtdt|SN USE_SHELLFrsuper__getattribute__)clsrI __class__r[r\__getattributeR z_GitMeta.__getattributevaluecs"|dkrt|t||dS)Nr)rr __setattr__)rrIrrr[r\ __setattrWsz_GitMeta.__setattrrIrJrEr)rIrJrrrEr) __name__ __module__ __qualname____doc___GitMeta__getattribute_GitMeta__setattrr"rr __classcell__r[r[rr\rLs rc seZdZUdZdZdZedZdddZ dd d Z d Z e j ddZ dZded< dZdZdZ eZeddddZedddZeeddd d!Zeeddd#d!Zeddd%d!Zedd&d'Zedd+d,ZGd-d.d.ZGd/d0d0Zddfd2d3 Z dfd6d7 Z!dfd8d9 Z"dd;d<Z#e$dd=d>Z%e$dd@dAZ&eddGdHZ'eddIddLdHZ'edddMddOdHZ'eddQdHZ'eddSdHZ'dddTdddTddTddde(j)dTf dfdedH Z'ddgdhZ*ddjdkZ+e,j-ddmdnZ.ddqdrZ/dddsdtZ0eddwdxZ1ddzd{Z2edd~dZ3edddZ3edddZ3dddZ3dddZ4dddZ5dddZ6dddZ7dddZ8dddZ9dddZ:dddZ;Z) raise)quietqsilencersilentnonen0)rwwarningloglr)rVe exceptionrr2ae %s All git commands will error until this is rectified. This initial message can be silenced or aggravated in the future by setting the $%s environment variable. Use one of the following values: - %s: for no message or exception - %s: for a warning message (logging level CRITICAL, displayed by default) - %s: for a raised exception Example: export %s=%s |ra %s environment variable has been set but it has been set with an invalid value. Use only the following values: - %s: for no message or exception - %s: for a warning message (logging level CRITICAL, displayed by default) - %s: for a raised exception )osr expanduserabspathenvironget_git_exec_env_var git_exec_namer_refresh_tokenrversionrPermissionErrorr_refresh_env_varlowerrprUcritical ImportError) rrnew_gitold_gitold_refresh_tokenhas_giterrmoderrrVr[r[r\refreshsz.       z Git.refreshcCs t|jSr)rr)rr[r[r\ is_cygwins z Git.is_cygwin.urlrJrLiteral[False]cCdSrr[rrrr[r[r\ polish_urlzGit.polish_urlUnion[None, bool]cCrrr[rr[r[r\rrr)cCsZ|dur|}|rt|}|Stj|}|dr!tj|}|dddd}|S)aRemove any backslashes from URLs to be written in config files. Windows might create config files containing paths with backslashes, but git stops liking them as it will escape the backslashes. Hence we undo the escaping just to be sure. N~z\\\/)rrrr expandvars startswithrrrr[r[r\rs  cCs.|j|}|r|d}td|ddS)a}Check for unsafe protocols. Apart from the usual protocols (http, git, ssh), Git allows "remote helpers" that have the form ``::
``. One of these helpers (``ext::``) can be used to invoke any arbitrary command. See: - https://git-scm.com/docs/gitremote-helpers - https://git-scm.com/docs/git-remote-ext zThe `zM::` protocol looks suspicious, use `allow_unsafe_protocols=True` to allow it.N)re_unsafe_protocolmatchgroupr)rrr protocolr[r[r\check_unsafe_protocolss   zGit.check_unsafe_protocolsoptionsrHunsafe_optionscCsPdd|D}|D]}t||D]\}}||s||kr$t|dqq dS)zCheck for unsafe options. Some options that are passed to ``git `` can be used to execute arbitrary commands. These are blocked by default. cSsg|]}|dqS)r)lstrip)roptionr[r[r\ sz,Git.check_unsafe_options..z= is not allowed, use `allow_unsafe_options=True` to allow it.N)zipr r)rrrbare_unsafe_optionsr unsafe_option bare_optionr[r[r\check_unsafe_optionss zGit.check_unsafe_optionsc@sVeZdZUdZdZdZded<dd d ZdddZdddZ dddZ dd ddZ dS)!r_aProcess wrapper that terminates the wrapped process on finalization. This kills/interrupts the stored process instance once this instance goes out of scope. It is used to prevent processes piling up in case iterators stop reading. All attributes are wired through to the contained process object. The wait method is overridden to perform automatic status code checking and possibly raise. r^r`statusrint_status_code_if_terminater^Union[None, subprocess.Popen]r`rrErFcCs||_||_d|_dSrr)rr^r`r[r[r\__init__s zGit.AutoInterrupt.__init__c Cs|jdurdS|j}d|_|jr|j|jr|j|jr%|jz|dur7|jp2||_WdSWntyP}z t d|WYd}~nd}~wwt dus]t t dddur_dSz| |}|jpl||_WdSty}z t d|WYd}~dSd}~ww)z!Terminate the underlying process.Nz(Ignored error after process had died: %rkill)r^stdinrWrbrcpollrrOSErrorrUinforrg terminatewait)rr^rZrr[r[r\rss:     zGit.AutoInterrupt._terminatecCs |dSr)rsrr[r[r\__del__rzGit.AutoInterrupt.__del__attrrJcCs t|j|Sr)rgr^)rr)r[r[r\ __getattr__rzGit.AutoInterrupt.__getattr__rcUnion[None, str, bytes]cs|durdt|dd|jdur|j}|jj}n|j}d}d fd d }|d kr@||}td |ftt|j |||S)aWait for the process and return its status code. :param stderr: Previously read value of stderr, in case stderr is already closed. :warn: May deadlock if output or error pipes are used and not handled separately. :raise git.exc.GitCommandError: If the return status is not 0. Nr+zutf-8)dataencodingrKUnion[IO[bytes], None]rErRc s>|rz t|WSttfypdYSwpdS)Nr+)r readr$ ValueError)rKstderr_br[r\$read_all_from_possibly_closed_stream4s zDGit.AutoInterrupt.wait..read_all_from_possibly_closed_streamrzAutoInterrupt wait stderr: %r)rKr/rErR) r r^r'rcrrUdebugr rr`)rrcrrwr4errstrr[r2r\r's      zGit.AutoInterrupt.waitN)r^rr`rrErFrErF)r)rJrEr)r+)rcr,rEr) rrrrrr__annotations__r rsr(r*r'r[r[r[r\rrs     # rrc@sdeZdZdZdZdd d Zddd dZddddZddddZd ddZ d!ddZ e Z d"ddZ dS)#zGit.CatFileContentStreamaObject representing a sized read-only stream returning the contents of an object. This behaves like a stream, but counts the data read and simulates an empty stream once our sized content region is empty. If not all data are read to the end of the object's lifetime, we read the rest to ensure the underlying stream continues to work. )_stream_nbr_sizesizerrK IO[bytes]rErFcCs,||_||_d|_|dkr|ddSdS)Nrr )r9r;r:r0)rr<rKr[r[r\r Ts z!Git.CatFileContentStream.__init__rRcCsn|j|j}|dkr dS|dkrt||}n|}|j|}|jt|7_|j|jdkr5|jd|S)Nrr+r>r )r;r:minr9r0lenrr< bytes_leftr-r[r[r\r0_s    zGit.CatFileContentStream.readcCsr|j|jkrdS|j|j}|dkrt||}n|}|j|}|jt|7_|j|jdkr7|jd|S)Nr+r>rr )r:r;r?r9readliner@r0rAr[r[r\rCts     z!Git.CatFileContentStream.readline List[bytes]cCsZ|j|jkrgSg}d} |}|s |S|||dkr,|t|7}||kr, |Sq )NrTr>)r:r;rCrkr@)rr<outnbrrXr[r[r\ readliness   z"Git.CatFileContentStream.readlines'Git.CatFileContentStream'cCs|Srr[rr[r[r\__iter__sz!Git.CatFileContentStream.__iter__cCs|}|st|Sr)rC StopIteration)rrXr[r[r\__next__sz!Git.CatFileContentStream.__next__cCs(|j|j}|r|j|ddSdS)Nr )r;r:r9r0)rrBr[r[r\r(s z Git.CatFileContentStream.__del__N)r<rrKr=rErF)r>)r<rrErR)r<rrErD)rErH)rErRr7) rrrrrr r0rCrGrIrKnextr(r[r[r[r\CatFileContentStreamGs     rM working_dircsBtt||_d|_g|_i|_d|_d|_d|_ d|_ dS)aaInitialize this instance with: :param working_dir: Git directory we should work in. If ``None``, we always work in the current directory as returned by :func:`os.getcwd`. This is meant to be the working tree directory if available, or the ``.git`` directory in case of bare repositories. r[N) rr rrrrrrrrr)rrNrr[r\r s  z Git.__init__rIrcrrrrrIrr[r\rrzGit.__getattribute__cs$dr tSfddS)zA convenience method as it allows to call the command as if it was an object. :return: Callable object that will execute call :meth:`_call_process` with your arguments. rcsjg|Ri|Sr) _call_process)r`rrIrr[r\z!Git.__getattr__..)r rrrOrrQr\r*s  zGit.__getattr__rcKs|jdddi||_dS)a7Specify command line options to the git executable for subsequent subcommand calls. :param kwargs: A dict of keyword arguments. These arguments are passed as in :meth:`_call_process`, but will be passed to the git command rather than the subcommand. split_single_char_optionsTNr[)transform_kwargsrrrr[r[r\set_persistent_git_optionss zGit.set_persistent_git_optionscC|jS)z(:return: Git directory we are working on)rrr[r[r\rNszGit.working_dirTuple[int, ...]cCs||j}|j|ur|jdusJd|jS|d}|dd}|ddd}ttj|}t t t ||_||_|jS)a :return: Tuple with integers representing the major, minor and additional version numbers as parsed from :manpage:`git-version(1)`. Up to four fields are used. This value is generated on demand and is cached. Nz Bug: corrupted token-check stater .) rrrrPrj itertools takewhilerJisdigitrhmapr)r refresh_tokenprocess_versionversion_stringversion_fieldsleading_numeric_fieldsr[r[r\ version_infos  zGit.version_inforrr0 Literal[True]'AutoInterrupt'cCrrr[)rrr0r[r[r\execute sz Git.execute)r0r5 Union[str, Tuple[int, str, str]]cCrrr[rrr0r5r[r[r\rj)r0r5$Union[bytes, Tuple[int, bytes, str]]cCrrr[rlr[r[r\rjrmr8cCrrr[rrr8r0r5r[r[r\rj#rRcCrrr[ror[r[r\rj-rpTr/Union[None, BinaryIO]r4r2r6rDr1r7r.r-Union[None, Mapping[str, str]]r3rr9subprocess_kwargsDUnion[str, bytes, Tuple[int, Union[str, bytes], str], AutoInterrupt]c st||jr|jdks|rtdz|jpt}tt |tj s)d}Wn t y5d}Ynw| }tj } d| d<d| d<| |j|durT| |tjdkre|durbtdt}nt }| rktn ttd dpvttjd }| durtd } td ||rd nd| zt|f| |d|ptt|| rtndd |Wn|y}zt||d}~wwt t!j"_"t t!j#_#|r|$|Stjdkr|dur|d&fdd }d'fdd }t%&t%j'|j(fdnj)}d}d}d}r dnd}zcdur9|\}}|*|r)|r)|dd}|*|r5|dd}j+}n.| rC| dkrC| nt,j-} t.j"| j"/}j#/}|*|rc|dd}0}Wj"1j#1n j"1j#1w|jdkrd}d(fd!d" }|rtd#||||t2|n|rtd$||||ntd%|||r|dkrt|||t3|t4r|rt2|}|r||t2|fS|S))aHandle executing the command, and consume and return the returned information (stdout). :param command: The command argument list to execute. It should be a sequence of program arguments, or a string. The program to execute is the first item in the args sequence or string. :param istream: Standard input filehandle passed to :class:`subprocess.Popen`. :param with_extended_output: Whether to return a (status, stdout, stderr) tuple. :param with_exceptions: Whether to raise an exception when git returns a non-zero status. :param as_process: Whether to return the created process instance directly from which streams can be read on demand. This will render `with_extended_output` and `with_exceptions` ineffective - the caller will have to deal with the details. It is important to note that the process will be placed into an :class:`AutoInterrupt` wrapper that will interrupt the process once it goes out of scope. If you use the command in iterators, you should pass the whole process instance instead of a single stream. :param output_stream: If set to a file-like object, data produced by the git command will be copied to the given stream instead of being returned as a string. This feature only has any effect if `as_process` is ``False``. :param stdout_as_string: If ``False``, the command's standard output will be bytes. Otherwise, it will be decoded into a string using the default encoding (usually UTF-8). The latter can fail, if the output contains binary data. :param kill_after_timeout: Specifies a timeout in seconds for the git command, after which the process should be killed. This will have no effect if `as_process` is set to ``True``. It is set to ``None`` by default and will let the process run until the timeout is explicitly specified. Uses of this feature should be carefully considered, due to the following limitations: 1. This feature is not supported at all on Windows. 2. Effectiveness may vary by operating system. ``ps --ppid`` is used to enumerate child processes, which is available on most GNU/Linux systems but not most others. 3. Deeper descendants do not receive signals, though they may sometimes terminate as a consequence of their parent processes being killed. 4. `kill_after_timeout` uses ``SIGKILL``, which can have negative side effects on a repository. For example, stale locks in case of :manpage:`git-gc(1)` could render the repository incapable of accepting changes until the lock is manually removed. :param with_stdout: If ``True``, default ``True``, we open stdout on the created process. :param universal_newlines: If ``True``, pipes will be opened as text, and lines are split at all known line endings. :param shell: Whether to invoke commands through a shell (see :class:`Popen(..., shell=True) `). If this is not ``None``, it overrides :attr:`USE_SHELL`. Passing ``shell=True`` to this or any other GitPython function should be avoided, as it is unsafe under most circumstances. This is because it is typically not feasible to fully consider and account for the effect of shell expansions, especially when passing ``shell=True`` to other methods that forward it to :meth:`Git.execute`. Passing ``shell=True`` is also no longer needed (nor useful) to work around any known operating system specific issues. :param env: A dictionary of environment variables to be passed to :class:`subprocess.Popen`. :param max_chunk_size: Maximum number of bytes in one chunk of data passed to the `output_stream` in one invocation of its ``write()`` method. If the given number is not positive then the default value is used. :param strip_newline_in_stdout: Whether to strip the trailing ``\n`` of the command stdout. :param subprocess_kwargs: Keyword arguments to be passed to :class:`subprocess.Popen`. Please note that some of the valid kwargs are already set by this method; the ones you specify may not be the same ones. :return: * str(output), if `extended_output` is ``False`` (Default) * tuple(int(status), str(stdout), str(stderr)), if `extended_output` is ``True`` If `output_stream` is ``True``, the stdout value will be your output stream: * output_stream, if `extended_output` is ``False`` * tuple(int(status), output_stream, str(stderr)), if `extended_output` is ``True`` Note that git is executed with ``LC_MESSAGES="C"`` to ensure consistent output regardless of system language. :raise git.exc.GitCommandError: :note: If you add additional keyword arguments to the signature of this method, you must update the ``execute_kwargs`` variable housed in this module. fullrZNCLANGUAGELC_ALLr~z9"kill_after_timeout" feature is not supported on Windows.rwbrzrFr>) r-cwdbufsizer"rcrbr.r7r.pidrrEc stddt|gtd}g}|jdur1|jD]}t|dkr0|d}|r0|t|qz%t |t j |D]}z t |t j Wq;t yOYq;wWdSt y`YdSw)zCallback to kill a process. This callback implementation would be ineffective and unsafe on Windows. psz--ppid)rbNr)rrJrrbr@rjr`rkrrr!signalSIGKILLr$set)r|p child_pidsrX local_pid child_pid) kill_checkr[r\ kill_process s.      z!Git.execute..kill_processTuple[AnyStr, AnyStr]csL\}}r"ddf}s"|t}||fS)Nz6Timeout: the command "%s" did not complete in %d secs.rZ)ro communicatecancelis_setrprur )rEr)rr^redacted_commandrer7watchdogr[r\r%s  z Git.execute..communicate)r`rr+  stdout_valueUnion[bytes, str]rJcs rt|pdS)Nz)r )r)r2r[r\as_textYszGit.execute..as_textz$%s -> %d; stdout: '%s'; stderr: '%s'z%s -> %d; stdout: '%s'z%s -> %d)r|rrErF)rEr)rrrErJ)5rrrUr%rprrgetcwdaccessrJX_OKFileNotFoundErrorrcopyupdatersysplatformr r$rrgropendevnullrrr5r}rr rr&rrbrcrrrlEventTimerr|rendswith returncodeioDEFAULT_BUFFER_SIZErr0r'rWr rQrR)rrr/r8r4r0r2r5r6r1r7r.r-r3r9rsrz inline_envcmd_not_found_exception stdout_sinkrrrrr stderr_valuenewlinecmdstrrr)rr2r^rrer7rr\rj7s                          Dict[str, str]cCrXr)rrr[r[r\ environmentxszGit.environmentDict[str, Union[str, None]]cKs^i}|D]&\}}|dur|j|||<||j|<q||jvr,|j|||<|j|=q|S)aSet environment variables for future git invocations. Return all changed values in a format that can be passed back into this function to revert the changes. Examples:: old_env = self.update_environment(PWD='/tmp') self.update_environment(**old_env) :param kwargs: Environment variables to use for git processes. :return: Dict that maps environment variables to their old values N)rrr)rrold_envkeyrr[r[r\update_environment{s  zGit.update_environmentIterator[None]c ksB|jdi|}zdVW|jdi|dS|jdi|w)agA context manager around the above :meth:`update_environment` method to restore the environment back to its previous state after operation. Examples:: with self.custom_environment(GIT_SSH='/bin/ssh_wrapper'): repo.remotes.origin.fetch() :param kwargs: See :meth:`update_environment`. Nr[)r)rrrr[r[r\custom_environments  &zGit.custom_environmentrrTcCst|dkr&|durd|gS|dvr$|rd|d|gSd||fgSgS|dur1dt|gS|durB|durBd t||fgSgS) Nr Tz-%s)FNz%sz-%s%sz--%sFz--%s=%s)r@r)rrIrrTr[r[r\transform_kwargs  zGit.transform_kwargcKsXg}|D]#\}}t|ttfr |D] }|||||7}qq|||||7}q|S)z.cSsi|] \}}|tvr||qSr[rrr[r[r\rrinsert_kwargs_afterNcSsg|]}|dur|qSrr[)rar[r[r\r#rSz%Git._call_process..zBCouldn't find argument '%s' in args %s to insert cmd options afterr r[)rpoprUrindexr1rJrrrrrkrrj) rrr`r exec_kwargs opts_kwargsinsert_after_this_argopt_argsext_args args_listrrcallr[r[r\rPs6(   $    header_lineTuple[str, str, int]cCs|}t|dkr'|sd|jd|jd}t|td|d|ft|ddkr5td||d|d t|d fS) a. :param header_line: A line of the form:: type_string size_as_int :return: (hex_sha, type_string, size_as_int) :raise ValueError: If the header contains indication for an error due to incorrect input sha. rz>SHA is empty, possible dubious ownership in the repository at zj. If this is unintended run: "git config --global --add safe.directory z" z.SHA %s could not be resolved, git returned: %rr(zFailed to parse header: %rr r[)rjr@rr1stripr)rrtokenserr_msgr[r[r\_parse_object_headerAs  zGit._parse_object_headerrefrcCsJt|tr |d}n t|tst|}n|}|ds |d7}|tS)Nasciir)rQrRrSrJrrur )rrrefstrr[r[r\ _prepare_ref`s      zGit._prepare_ref attr_namecmd_namecOs\t||}|dur |Stdd}|||j|g|Ri|}t|||td|}|S)NT)r/r0r_)rgrrrPrr&)rrrr`rcur_valrcmdr[r[r\_get_persistent_cmdns     zGit._get_persistent_cmdrcCs@|jr|jr|j|||j||jStd)Nzcmd stdin was empty)r"rbwriterflushrrCr1)rrrr[r[r\__get_object_header{s  zGit.__get_object_headercCs|jdddd}|||S)aDUse this method to quickly examine the type and size of the object behind the given ref. :note: The method will only suffer from the costs of command invocation once and reuses the command in subsequent calls. :return: (hexsha, type_string, size_as_int) rcat_fileT) batch_check)r_Git__get_object_header)rrrr[r[r\get_object_headers zGit.get_object_headerTuple[str, str, int, bytes]cCs*||\}}}}||}~||||fS)zSimilar to :meth:`get_object_header`, but returns object data as well. :return: (hexsha, type_string, size_as_int, data_string) :note: Not threadsafe. )stream_object_datar0)rrhexshatypenamer<rKr-r[r[r\get_object_datas  zGit.get_object_data0Tuple[str, str, int, 'Git.CatFileContentStream']cCsN|jdddd}|||\}}}|jdur|jnt}||||||fS)a$Similar to :meth:`get_object_data`, but returns the data as a stream. :return: (hexsha, type_string, size_as_int, stream) :note: This method is not threadsafe. You need one independent :class:`Git` instance per thread to be safe! rrT)batchN)rrrbrBytesIOrM)rrrrrr< cmd_stdoutr[r[r\rs zGit.stream_object_datacCs.|j|jfD]}|r|qd|_d|_|S)zClear all kinds of internal caches to release resources. Currently persistent commands will be interrupted. :return: self N)rrr()rrr[r[r\ clear_cacheszGit.clear_cache)rEr)rrrErFr)rrrErC)rErC).)rrJrrrErJ)rrJrrrErJ)rrJrrrEr))rrJrErF)rrHrrHrErF)rNrrErFr)rrrErF)rEr)rErY)rrr0rhrEri)rrr0rr5rhrErk)rrr0rr5rrErn) rrr8rr0rr5rhrErJ) rrr8rr0rr5rrErR) rrr/rqr8rCr4rCr0rCr2rqr5rCr6rDr1rCr7rCr.rr-rrr3rr9rCrsrrErt)rEr)rrrEr)rrrEr)rIrJrrrTrCrErH)T)rTrCrrrErH)rrrErH)rrrEr)rrJr`rFrrFrErJ) rrJr/rr0rhr`rrrrEr)rrJr`rrrrEr)rrJrEr)rrrErR) rrJrrJr`rrrrEr)rrrrrEr)rrJrEr)rrJrEr)rrJrEr)rEr)=rrrrrrrecompiler rrrrrrrrr8rrrrr classmethodrrr'rrrrrrMr rr*rWpropertyrNrgrjrrrr contextlibcontextmanagerrrrUrrrPrrrrrrrrrr[r[rr\rs     0&   ll        C           N     ) metaclass)NTN)r:r;r<r=r>r?r@rArBrCr6rDrErF) rrr.rCr-rrrrEr)rrJrErJ)r[)rrrrrEr)rrrrrrrErF)rrCrErF)Q __future__r__all__rrr^loggingrrr~rrrrrtextwraprrlr git.compatr r r git.excr r rrrgit.utilrrrrrrtypingrrrrrrrrrr r!r"r#r$r%r&r' git.typesr(r)r*git.diffr+ git.repo.baser,r getLoggerrrUr|r8rrr}rrrrrrtyperrrr[r[r[r\s`  L      =