HEX
Server: LiteSpeed
System: Linux s787.bom1.mysecurecloudhost.com 4.18.0-477.13.1.lve.el8.x86_64 #1 SMP Thu Jun 1 16:40:47 EDT 2023 x86_64
User: mobilech (5348)
PHP: 8.1.34
Disabled: NONE
$ pwd: /opt/saltstack/salt/lib/python3.10/site-packages/git/__pycache__/
Upload Files
File: //opt/saltstack/salt/lib/python3.10/site-packages/git/__pycache__/cmd.cpython-310.pyc
o

;j��@sdUddlmZddgZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddl
mZm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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ej6dkr�ddl$m7Z7nddl8m7Z7dd
l9m:Z:m;Z;m<Z<e0r�ddl=m>Z>ddl?m@Z@hd�ZAe�BeC�ZD			dTdUd d!�ZEd"eFd#<ejGd$kr�d%dd&�dVd/d0�ZHeHZIne
ZIdWd3d4�ZJdXdYd;d<�ZKdXdZdAdB�ZLGdCdD�dD�ZMdEeM_CdFeM_NGdGdH�dH�ZOdIeO_CdJeO_NdKZPdLZQd[dNdO�ZRGdPdQ�dQeS�ZTeTZU	GdRd�deTdS�ZVdS)\�)�annotations�GitMeta�GitN)�DEVNULL�PIPE�Popen)�dedent)�defenc�force_bytes�safe_decode)�CommandError�GitCommandError�GitCommandNotFound�UnsafeOptionError�UnsafeProtocolError)�cygpath�expand_path�
is_cygwin_git�	patch_env�remove_password_if_present�stream_copy)�Any�AnyStr�BinaryIO�Callable�Dict�IO�Iterator�List�Mapping�Optional�Sequence�
TYPE_CHECKING�TextIO�Tuple�Union�cast�overload)��
)�	TypeAlias)�Literal�PathLike�TBD)�	DiffIndex)�Repo>
�max_chunk_size�istream�stdout_as_string�universal_newlines�with_extended_output�
output_stream�kill_after_timeout�env�with_stdout�shell�
as_process�strip_newline_in_stdout�with_exceptionsT�process�'Git.AutoInterrupt' | Popen�stdout_handler�sUnion[None, Callable[[AnyStr], None], Callable[[List[AnyStr]], None], Callable[[bytes, 'Repo', 'DiffIndex'], None]]�stderr_handler�EUnion[None, Callable[[AnyStr], None], Callable[[List[AnyStr]], None]]�	finalizer�@Union[None, Callable[[Union[Popen, 'Git.AutoInterrupt']], None]]�decode_streams�boolr6�Union[None, float]�return�NonecCs�dd
d�}t|d�r)td|�}t|jdd�}|jr|jjnd}|jr&|jjnd}	ntt|�}t|dd�}|j}|j}	t|tt	f�sE|�
�}g}
|rQ|
�d||f�|	r[|
�d|	|f�g}|
D]\}}
}tj
||||
||fd�}d|_|��|�|�q_|D];}|j|d�|��r�t|tj�r�|��ntd|�d���|r�d|�d�}|s�t|	t�r�tt|�}|��}||�q|r�||�dSdS)a�Register 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]�name�str�stream�Union[BinaryIO, TextIO]�	is_decoderF�handler�0Union[None, Callable[[Union[bytes, str]], None]]rHrIcSs�zfz |D]}|r|rt|t�sJ�|�t�}||�q||�qWn7tyX}z+t�d|�dt|��d|���dt|�vrNt	d|�d�gt|�|�|�WYd}~nd}~wwW|�
�dSW|�
�dS|�
�w)NzPumping z of cmd(z) failed due to: zI/O operation on closed file�<z-pump>)�
isinstance�bytes�decoder	�	Exception�_logger�errorrrMr�close)rJrLrNrPrQ�lineZline_str�ex�r]�;/opt/saltstack/salt/lib/python3.10/site-packages/git/cmd.py�pump_stream�s*

��	 �����z*handle_process_output.<locals>.pump_stream�proc�Git.AutoInterrupt�args�N�stdout�stderr)�targetrbT)�timeoutzKThread join() timed out in cmd.handle_process_output(). kill_after_timeout=z secondsz?error: process killed because it timed out. kill_after_timeout=)rJrKrLrMrNrOrPrFrQrRrHrI)�hasattrr&�getattrr`rdrerrT�tuple�list�split�append�	threading�Thread�daemon�start�join�is_aliver�
AutoInterrupt�
_terminate�RuntimeErrorrrM�encode)r=r?rArCrEr6r_rJZp_stdout�p_stderrZpumps�threadsrLrNrQ�tZ	error_strr]r]r^�handle_process_outputfsX
/



��
�
��r{zCallable[..., Popen]�safer_popen�win32F)r9r7�command�Union[str, Sequence[Any]]r9r7�Optional[Mapping[str, str]]�kwargsrrcKsrtjtjB}|r|durint|�}d|d<tdd��t|f|||d�|��Wd�S1s2wYdS)a�Call :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
        N�1Z"NoDefaultCurrentDirectoryInExePath)r9r7�
creationflags)�
subprocessZCREATE_NO_WINDOWZCREATE_NEW_PROCESS_GROUP�dictrr)r~r9r7r�r�r]r]r^�_safer_popen_windows�s$	���$�r��stringrMcCs|�dd�S)N�_�-)�replace)r�r]r]r^�dashify+�r�r]�self�'Git'�exclude�
Sequence[str]�Dict[str, Any]cs��fdd��jD�S)Ncs i|]}|�vr|t�|��qSr])ri)�.0�s�r�r�r]r^�
<dictcomp>0s z!slots_to_dict.<locals>.<dictcomp>)�	__slots__)r�r�r]r�r^�
slots_to_dict/sr��object�d�Mapping[str, Any]�excludedcCs8|��D]
\}}t|||�q|D]}t||d�qdS�N)�items�setattr)r�r�r��k�vr]r]r^�$dict_to_slots_and__excluded_are_none3s
�r�c@sVeZdZUdZdZdZded<ddd
�Zddd�Zddd�Z	ddd�Z
dd dd�ZdS)!�_AutoInterrupta�Process 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`rb�statusr�int�_status_code_if_terminater`�Union[None, subprocess.Popen]rbrrHrIcCs||_||_d|_dSr�r�)r�r`rbr]r]r^�__init__Os
z_AutoInterrupt.__init__c
Cs|jdurdS|j}d|_|jr|j��|jr|j��|jr%|j��z|��dur7|jp2|��|_WdSWntyP}zt	�
d|�WYd}~nd}~wwtdus]ttdd�dur_dSz|�
�|��}|jpl||_WdSttfy�}z
t	�
d|�WYd}~dSd}~ww)z!Terminate the underlying process.Nz(Ignored error after process had died: %r�killz+Ignored error while terminating process: %r)r`�stdinrZrdre�pollr�r��OSErrorrX�info�osri�	terminate�wait�AttributeError)r�r`r\r�r]r]r^ruTs:



�����z_AutoInterrupt._terminatecCs|��dSr�)ru�r�r]r]r^�__del__{r�z_AutoInterrupt.__del__�attrrMcCst|j|�Sr�)rir`)r�r�r]r]r^�__getattr__~r�z_AutoInterrupt.__getattr__�re�Union[None, str, bytes]cs�|durd�t|dd��|jdur|j��}|jj}n|j}d}d
�fd	d
�}|dkr@||�}t�d|f�tt|j	�||��|S)a[Wait 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)�data�encodingrN�Union[IO[bytes], None]rHrUc	s>|rz	�t|���WSttfy�pdYSw�pdS)Nr�)r
�readr��
ValueError)rN�Zstderr_br]r^�$read_all_from_possibly_closed_stream�s�zA_AutoInterrupt.wait.<locals>.read_all_from_possibly_closed_streamrzAutoInterrupt wait stderr: %r)rNr�rHrU)
r
r`r�rer�rX�debugr
rrb)r�rer�rxr�Zerrstrr]r�r^r��s


z_AutoInterrupt.waitN)r`r�rbrrHrI�rHrI)r�rMrHr)r�)rer�rHr�)�__name__�
__module__�__qualname__�__doc__r�r��__annotations__r�rur�r�r�r]r]r]r^r�=s



'
r�rtrac@sdeZdZdZdZdd	d
�Zddd
d�Zdddd�Zdddd�Zd dd�Z	d!dd�Z
e
Zd"dd�ZdS)#�_CatFileContentStreamaiObject 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�_size�sizer�rN�	IO[bytes]rHrIcCs,||_||_d|_|dkr|�d�dSdS)Nr�)r�r�r�r�)r�r�rNr]r]r^r��s�z_CatFileContentStream.__init__���rUcCsn|j|j}|dkrdS|dkrt||�}n|}|j�|�}|jt|�7_|j|jdkr5|j�d�|S)Nrr�r�r�)r�r��minr�r��len�r�r��
bytes_leftr�r]r]r^r��sz_CatFileContentStream.readcCsr|j|jkrdS|j|j}|dkrt||�}n|}|j�|�}|jt|�7_|j|jdkr7|j�d�|S)Nr�r�rr�)r�r�r�r��readliner�r�r�r]r]r^r��sz_CatFileContentStream.readline�List[bytes]cCsZ|j|jkrgSg}d}	|��}|s	|S|�|�|dkr,|t|�7}||kr,	|Sq
)NrTr�)r�r�r�rmr�)r�r��outZnbrr[r]r]r^�	readlines�s 
��z_CatFileContentStream.readlines�'Git.CatFileContentStream'cCs|Sr�r]r�r]r]r^�__iter__sz_CatFileContentStream.__iter__cCs|��}|st�|Sr�)r��
StopIteration)r�r[r]r]r^�__next__
sz_CatFileContentStream.__next__cCs(|j|j}|r|j�|d�dSdS)Nr�)r�r�r�r�)r�r�r]r]r^r�s�z_CatFileContentStream.__del__N)r�r�rNr�rHrI)r�)r�r�rHrU)r�r�rHr�)rHr�)rHrUr�)
r�r�r�r�r�r�r�r�r�r�r��nextr�r]r]r]r^r��s



r��CatFileContentStreamzGit.CatFileContentStreamzuGit.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|rtnttdd�dS)Nr()�
stacklevel)�warnings�warn�_USE_SHELL_DANGER_MESSAGE�_USE_SHELL_DEFAULT_MESSAGE�DeprecationWarning�r�r]r]r^�_warn_use_shell-s


�r�csDeZdZdZd�fdd�Zd�fd	d
�ZeseZeZ�Z	S�Z	S)
�_GitMetaztMetaclass for :class:`Git`.

    This helps issue :class:`DeprecationWarning` if :attr:`Git.USE_SHELL` is used.
    rLrMrHrc�|dkr	tdd�t��|�S�N�	USE_SHELLFr��r��super�__getattribute__)�clsrL��	__class__r]r^Z__getattribute;�
z_GitMeta.__getattribute�valuecs$|dkr	t|d�t��||�dS)Nr�r�)r�r��__setattr__)r�rLr�r�r]r^Z	__setattr@s
z_GitMeta.__setattr�rLrMrHr)rLrMr�rrHr)
r�r�r�r�Z_GitMeta__getattributeZ_GitMeta__setattrr"r�r��
__classcell__r]r]r�r^r�5s�r�c
s�eZdZUdZdZdZe�d�Zd�dd�Z	d�dd�Z
d
Z	ej
�dd�Z	dZded<	dZdZdZ	e�Zed�d�dd��Zed�dd��Zeed�d�d d!���Zeed�d�d#d!���Zed�d�d%d!��Zed�d&d'��Zed�d)d*��Zed�d.d/��ZeZ d0ed1<e!Z"d0ed2<d�d��fd4d5�
Z#d��fd8d9�Z$d��fd:d;�Z%d�d=d>�Z&e'd�d?d@��Z(e'd�dBdC��Z)ed�dIdJ��Z*eddK�d�dNdJ��Z*edddO�d�dQdJ��Z*ed�dSdJ��Z*ed�dUdJ��Z*dddVdddVddVddde+j,dVf
d��fdgdJ�
Z*d�didj�Z-d�dldm�Z.e/j0d�dodp��Z1d�dsdt�Z2d�d�dudv�Z3ed�dydz��Z4d�d|d}�Z5ed�d�d���Z6ed�d�d���Z6ed�d�d���Z6d�d�d��Z6d�d�d��Z7d�d�d��Z8d�d�d��Z9d�d�d��Z:d�d�d��Z;d�d�d��Z<d�d�d��Z=d�d�d��Z>�Z?S)�ra�The Git class manages communication with the Git binary.

    It provides a convenient interface to calling the Git binary, such as in::

     g = Git( git_dir )
     g.init()                   # calls 'git init' program
     rval = g.ls_files()        # calls 'git ls-files' program

    Debugging:

    * Set the :envvar:`GIT_PYTHON_TRACE` environment variable to print each invocation
      of the command to stdout.
    * Set its value to ``full`` to see details about the returned values.
    )�_working_dir�cat_file_all�cat_file_header�
_version_info�_version_info_token�_git_options�_persistent_git_options�_environment)r�r�r�r�z(.+)::.+rHr�cCst||jd�S)N)r�)r��
_excluded_r�r]r]r^�__getstate__�szGit.__getstate__r�rIcCst|||jd�dS)N)r�)r�r�)r�r�r]r]r^�__setstate__�szGit.__setstate__�git�GIT_PYTHON_TRACEFrFr��GIT_PYTHON_GIT_EXECUTABLEZGIT_PYTHON_REFRESHN�path�Union[None, PathLike]c	Cs�|durtj�|�}tj�|�}n	tj�|j|j�}|j}|j	}||_t
�|_	d}z	|���d}Wntt
fy=Ynw|s�td�|j}||_||_	|dur�tj�|jd���}gd�}gd�}	gd�}
||vrlnH||	vst||
vr�td	�||jd
�|�d
�|	�d
�|
�|j|df}||	vr�t�|�nt|��td�|jd
�|�d
�|	�d
�|
�f}t|��|j|_|St||��|S)
a5	Update information about the git executable :class:`Git` objects will use.

        Called by the :func:`git.refresh` function in the top level ``__init__``.

        :param path:
            Optional path to the git executable. If not absolute, it is resolved
            immediately, relative to the current directory. (See note below.)

        :note:
            The top-level :func:`git.refresh` should be preferred because it calls this
            method and may also update other state accordingly.

        :note:
            There are three different ways to specify the command that refreshing causes
            to be used for git:

            1. Pass no `path` argument and do not set the
               :envvar:`GIT_PYTHON_GIT_EXECUTABLE` environment variable. The command
               name ``git`` is used. It is looked up in a path search by the system, in
               each command run (roughly similar to how git is found when running
               ``git`` commands manually). This is usually the desired behavior.

            2. Pass no `path` argument but set the :envvar:`GIT_PYTHON_GIT_EXECUTABLE`
               environment variable. The command given as the value of that variable is
               used. This may be a simple command or an arbitrary path. It is looked up
               in each command run. Setting :envvar:`GIT_PYTHON_GIT_EXECUTABLE` to
               ``git`` has the same effect as not setting it.

            3. Pass a `path` argument. This path, if not absolute, is immediately
               resolved, relative to the current directory. This resolution occurs at
               the time of the refresh. When git commands are run, they are run using
               that previously resolved path. If a `path` argument is passed, the
               :envvar:`GIT_PYTHON_GIT_EXECUTABLE` environment variable is not
               consulted.

        :note:
            Refreshing always sets the :attr:`Git.GIT_PYTHON_GIT_EXECUTABLE` class
            attribute, which can be read on the :class:`Git` class or any of its
            instances to check what command is used to run git. This attribute should
            not be confused with the related :envvar:`GIT_PYTHON_GIT_EXECUTABLE`
            environment variable. The class attribute is set no matter how refreshing is
            performed.
        NFTa0                Bad git executable.
                The git executable must be specified in one of the following ways:
                    - be included in your $PATH
                    - be set via $%s
                    - explicitly set via git.refresh(<full-path-to-git-executable>)
                �raise)�quiet�qZsilencer�Zsilent�none�n�0)r��w�warning�log�lr�)rY�e�	exceptionr�r�2ae                        %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
                        )r�r�
expanduser�abspath�environ�get�_git_exec_env_var�
git_exec_namer�_refresh_tokenr��versionr�PermissionErrorr�_refresh_env_var�lowerrrrX�critical�ImportError)r�rZnew_gitZold_gitZold_refresh_tokenZhas_git�err�moderr�rYr]r]r^�refresh�sz.
��	������
��
�zGit.refreshcCs
t|j�Sr�)rr�r�r]r]r^�	is_cygwins
z
Git.is_cygwin.�urlrMr$�Literal[False]cC�dSr�r]�r�r%r$r]r]r^�
polish_url��zGit.polish_url�Union[None, bool]cCr'r�r]r(r]r]r^r)�r*r,cCsZ|dur|��}|rt|�}|Stj�|�}|�d�r!tj�|�}|�dd��dd�}|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\\�\�/)r$rr�r�
expandvars�
startswithrr�r(r]r]r^r)�s�
cCs.|j�|�}|r|�d�}td|�d���dS)a}Check for unsafe protocols.

        Apart from the usual protocols (http, git, ssh), Git allows "remote helpers"
        that have the form ``<transport>::<address>``. 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
        r�zThe `zM::` protocol looks suspicious, use `allow_unsafe_protocols=True` to allow it.N)�re_unsafe_protocol�match�groupr)r�r%r2�protocolr]r]r^�check_unsafe_protocols�s


��zGit.check_unsafe_protocols�optioncCs6|�d��dd�d}|�dd�}|sdSt|d�S)aReturn the option name used for unsafe-option checks.

        Examples:
            ``"--upload-pack=/tmp/helper"`` -> ``"upload-pack"``
            ``"upload_pack"`` -> ``"upload-pack"``
            ``"--config core.filemode=false"`` -> ``"config"``
        r��=r�rNrc)�lstriprlr�)r�r6Zoption_nameZ
option_tokensr]r]r^�_canonicalize_option_name�s
	zGit._canonicalize_option_name�optionsrK�unsafe_optionscsF�fdd�|D�}|D]}|���|��}|dur t|�d���qdS)z�Check for unsafe options.

        Some options that are passed to ``git <command>`` can be used to execute
        arbitrary commands. These are blocked by default.
        csi|]}��|�|�qSr])r9)r�r6r#r]r^r���z,Git.check_unsafe_options.<locals>.<dictcomp>Nz= is not allowed, use `allow_unsafe_options=True` to allow it.)rr9r)r�r:r;Zcanonical_unsafe_optionsr6Z
unsafe_optionr]r#r^�check_unsafe_options�s��zGit.check_unsafe_optionsr*rtr��working_dircsBt���t|�|_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)r�r�rr�r�r�r�r�r�r�r�)r�r>r�r]r^r��s
	

zGit.__init__rLrcr�r�r��r�rLr�r]r^r��r�zGit.__getattribute__cs$��d�rt����S��fdd�S)z�A 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.
        r�cs�j�g|�Ri|��Sr�)�
_call_process)rbr��rLr�r]r^�<lambda>�r<z!Git.__getattr__.<locals>.<lambda>)r0r�r�r?r�rAr^r��s
zGit.__getattr__r�cKs|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_kwargsr��r�r�r]r]r^�set_persistent_git_options�s
zGit.set_persistent_git_optionscC�|jS)z(:return: Git directory we are working on)r�r�r]r]r^r>	szGit.working_dir�Tuple[int, ...]cCs||j}|j|ur|jdusJd��|jS|�d�}|�d�d}|�d�dd�}t�tj|�}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� ��.�)rr�r�r@rl�	itertools�	takewhilerM�isdigitrj�mapr�)r�Z
refresh_tokenZprocess_versionZversion_stringZversion_fieldsZleading_numeric_fieldsr]r]r^�version_infos


zGit.version_infor~rr:�
Literal[True]�'AutoInterrupt'cCr'r�r])r�r~r:r]r]r^�execute*szGit.execute)r:r2� Union[str, Tuple[int, str, str]]cCr'r�r]�r�r~r:r2r]r]r^rT2�)r:r2�$Union[bytes, Tuple[int, bytes, str]]cCr'r�r]rVr]r]r^rT;rWr4cCr'r�r]�r�r~r4r:r2r]r]r^rTD�rUcCr'r�r]rYr]r]r^rTNrZTr1�Union[None, BinaryIO]r<r5r6rGr8r3r9r7�Union[None, Mapping[str, str]]r0r�r;�subprocess_kwargs�DUnion[str, bytes, Tuple[int, Union[str, bytes], str], AutoInterrupt]cs$t|��|jr|jdks|rt�d����z|jpt��}t�t	|�tj
�s)d}Wnty5d}Ynw|}tj�
�}d|d<d|d<|�|j�|durT|�|�tjdkre|durbt�d��t}nt}|	rktnttd	d�pvttjd
�}|dur�t��d�}t�d�||r�d
nd|��zt|f||d|p�tt||��r�tndd�	|���Wn|y�}zt�|�|�d}~wwt t!�j"��_"t t!�j#��_#|r�|�$�|�Stjdkr�|dur�|�d&�fdd�}d'������fdd�}t%�&��t%j'�|�j(fd��n�j)}d}d}d}��r
dnd}z��du�rC|�\}}|du�r.|�*|��r.|�r.|dd�}|du�r?|�*|��r?|dd�}�j+}n?|
�rM|
dk�rM|
nt,j-}
�j"du�rbt.�j"�|
��j"�/�}�j#du�rm�j#�/�}|du�r~|�*|��r~|dd�}��0�}W�j"du�r��j"�1��j#du�r��j#�1�n�j"du�r��j"�1��j#du�r��j#�1�ww|jdk�r�d���}d(�fd!d"�}|�r�t�d#||||�t2|��n|�r�t�d$||||��nt�d%||�|�r�|dk�r�t�|||��t3|t4��r|�rt2|�}|�r||t2|�fS|S))a�Handle 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) <subprocess.Popen>`).
            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.
        �fullrIN�C�LANGUAGE�LC_ALLr}z9"kill_after_timeout" feature is not supported on Windows.r�wbr�z<Popen(%s, cwd=%s, stdin=%s, shell=%s, universal_newlines=%s)z<valid stream>rIr�)	r7�cwd�bufsizer�rerdr9r3r��pidr�rHc	s�tddt|�gtd�}g}|jdur1|jD]}t|���dkr0|��d}|��r0|�t|��qz%t	�
|tj�|D]}z	t	�
|tj�Wq;t
yOYq;w���WdSt
y`YdSw)z�Callback to kill a process.

                This callback implementation would be ineffective and unsafe on Windows.
                Zpsz--ppid)rdNr)rrMrrdr�rlrOrmr�r�r��signal�SIGKILLr��set)rf�pZ
child_pidsr[Z	local_pidZ	child_pid)�
kill_checkr]r^�kill_process*s.

��
��z!Git.execute.<locals>.kill_process�Tuple[AnyStr, AnyStr]csL������\}}������r"dd����f}�s"|�t�}||fS)Nz6Timeout: the command "%s" did not complete in %d secs.rI)rq�communicate�cancel�is_setrrrwr	)r�r )rkr`�redacted_commandrgr3�watchdogr]r^rnFs�
z Git.execute.<locals>.communicate)rbrr��
�
�stdout_value�Union[bytes, str]rMcs�rt|�pdS)Nz<OUTPUT_STREAM>)r)ru)r5r]r^�as_text~szGit.execute.<locals>.as_textz$%s -> %d; stdout: '%s'; stderr: '%s'z%s -> %d; stdout: '%s'z%s -> %d)rfr�rHrI)rHrm)rurvrHrM)5rrrXr�rrr�r��getcwd�accessrM�X_OK�FileNotFoundErrorr�copy�updater��sys�platformr
r�rrir��open�devnullr�r�r�r|rr	rr&rrdrertrn�Event�Timerrfrn�endswith�
returncode�io�DEFAULT_BUFFER_SIZErr�r�rZrrTrU)r�r~r1r4r<r:r5r2r6r8r3r9r7r0r;r]rdZ
inline_envZcmd_not_found_exceptionZstdout_sinkr rlrnr�ruZstderr_value�newlineZcmdstrrwr�)rkr5r`rqrgr3rrr^rTXs���


� 
��
�
�
��



�

��
�
��Dict[str, str]cCrGr�)r�r�r]r]r^�environment�szGit.environment�Dict[str, Union[str, None]]cKs^i}|��D]&\}}|dur|j�|�||<||j|<q||jvr,|j|||<|j|=q|S)a�Set 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)r�r�r)r�r��old_env�keyr�r]r]r^�update_environment�s
�zGit.update_environment�Iterator[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�)r�r�r�r]r]r^�custom_environment�s
�
&zGit.custom_environmentr�rCcCs�t|�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�)r�rLr�rCr]r]r^�transform_kwarg�s
�zGit.transform_kwargcKsXg}|��D]#\}}t|ttf�r |D]}||�|||�7}qq||�|||�7}q|S)z<Transform Python-style kwargs into git command line options.)r�rTrkrjr�)r�rCr�rbr�r�r�r]r]r^rD�s�zGit.transform_kwargs�arg_listr�cCsBg}t|ttf�r|D]
}|�|�|��q|S|�t|��|Sr�)rTrkrj�extend�_unpack_argsrmrM)r�r�Zoutlist�argr]r]r^r��s�zGit._unpack_argsr�cKs|jdddi|��|_|S)agSpecify command line options to the git executable for a subcommand call.

        :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.

        Examples::

            git(work_tree='/tmp').difftool()
        rCTNr])rDr�rEr]r]r^�__call__�szGit.__call__�methodrbcOr'r�r]�r�r�rbr�r]r]r^r@�zGit._call_process�'Git.AutoInterrupt'cOr'r�r])r�r�r1r:rbr�r]r]r^r@	rZ�JUnion[str, bytes, Tuple[int, Union[str, bytes], str], 'Git.AutoInterrupt']cOr'r�r]r�r]r]r^r@r�c

Osdd�|��D�}dd�|��D�}|�dd�}|jd
i|��}|�dd�|D��}|dur3||}	n1z|�|�}
WntyQ}ztd|t|�f�|�d}~ww|d|
d	�|||
d	d�}	|jg}|�|j	�|�|j
�d
|_
|�t|��|�|	�|j
|fi|��S)aRun the given git command with the specified arguments and return the result
        as a string.

        :param method:
            The command. Contained ``_`` characters will be converted to hyphens, such
            as in ``ls_files`` to call ``ls-files``.

        :param args:
            The list of arguments. If ``None`` is included, it will be pruned.
            This allows your commands to call git more conveniently, as ``None`` is
            realized as non-existent.

        :param kwargs:
            Contains key-values for the following:

            - The :meth:`execute()` kwds, as listed in ``execute_kwargs``.
            - "Command options" to be converted by :meth:`transform_kwargs`.
            - The ``insert_kwargs_after`` key which its value must match one of
              ``*args``.

            It also contains any command options, to be appended after the matched arg.

        Examples::

            git.rev_list('master', max_count=10, header=True)

        turns into::

            git rev-list --max-count=10 --header=master

        :return:
            Same as :meth:`execute`. If no args are given, used :meth:`execute`'s
            default (especially ``as_process = False``, ``stdout_as_string = True``) and
            return :class:`str`.
        cSsi|]\}}|tvr||�qSr]��execute_kwargs�r�r�r�r]r]r^r�@�z%Git._call_process.<locals>.<dictcomp>cSsi|]\}}|tvr||�qSr]r�r�r]r]r^r�Ar�Zinsert_kwargs_afterNcSsg|]}|dur|�qSr�r])r��ar]r]r^�
<listcomp>Hr<z%Git._call_process.<locals>.<listcomp>zBCouldn't find argument '%s' in args %s to insert cmd options afterr�r])r��poprDr��indexr�rMrr�r�r�rmr�rT)
r�r�rbr�Zexec_kwargsZopts_kwargsZinsert_after_this_argZopt_argsZext_argsZ	args_listr�r �callr]r]r^r@s6(

�����$
�header_line�Tuple[str, str, int]cCs�|��}t|�dkr'|sd|j�d|j�d�}t|��td|d|��f��t|d�dkr5td|��|d|d	t|d
�fS)a.
        :param header_line:
            A line of the form::

                <hex_sha> 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.
        r(z>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�rJ)rlr�r�r��stripr�)r�r��tokens�err_msgr]r]r^�_parse_object_headerfs
���zGit._parse_object_header�refrcCsJt|t�r|�d�}nt|t�st|�}n|}|�d�s |d7}|�t�S)N�asciirs)rTrUrVrMr�rwr	)r�r�Zrefstrr]r]r^�_prepare_ref�s




zGit._prepare_ref�	attr_name�cmd_namecOs\t||�}|dur|Stdd�}|�|�|j|g|�Ri|��}t|||�td|�}|S)NT)r1r:ra)rirr}r@r�r&)r�r�r�rbr�Zcur_valr:�cmdr]r]r^�_get_persistent_cmd�s



zGit._get_persistent_cmdr�cCs@|jr|jr|j�|�|��|j��|�|j���Std��)Nzcmd stdin was empty)r�rd�writer��flushr�r�r�)r�r�r�r]r]r^Z__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)
        r��cat_fileT)Zbatch_check)r��_Git__get_object_header)r�r�r�r]r]r^�get_object_header�szGit.get_object_header�Tuple[str, str, int, bytes]cCs*|�|�\}}}}|�|�}~||||fS)z�Similar 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_datar�)r�r��hexsha�typenamer�rNr�r]r]r^�get_object_data�s	
zGit.get_object_data�0Tuple[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!
        r�r�T)ZbatchN)r�r�rdr��BytesIOr�)r�r�r�r�r�r�Z
cmd_stdoutr]r]r^r��s
zGit.stream_object_datacCs.|j|jfD]}|r|��qd|_d|_|S)z�Clear all kinds of internal caches to release resources.

        Currently persistent commands will be interrupted.

        :return:
            self
        N)r�r�r�)r�r�r]r]r^�clear_cache�s�zGit.clear_cache)rHr�)r�r�rHrIr�)rrrHrF)rHrF).)r%rMr$r&rHrM)r%rMr$r+rHrM)r%rMr$r+rHr,)r%rMrHrI)r6rMrHrM)r:rKr;rKrHrI)r>rrHrIr�)r�rrHrI)rHr)rHrH)r~rr:rRrHrS)r~rr:r&r2rRrHrU)r~rr:r&r2r&rHrX)
r~rr4r&r:r&r2rRrHrM)
r~rr4r&r:r&r2r&rHrU) r~rr1r[r4rFr<rFr:rFr5r[r2rFr6rGr8rFr3rFr9r+r7r\r0r�r;rFr]rrHr^)rHr�)r�rrHr�)r�rrHr�)rLrMr�rrCrFrHrK)T)rCrFr�rrHrK)r�r�rHrK)r�rrHr�)r�rMrbrIr�rIrHrM)r�rMr1r�r:rRrbrr�rrHr�)r�rMrbrr�rrHr�)r�rMrHr�)r�rrHrU)
r�rMr�rMrbrr�rrHr�)r�r�r�rrHr�)r�rMrHr�)r�rMrHr�)r�rMrHr�)rHr�)@r�r�r�r�r�r��re�compiler1r�r�rr�rrrr�r�rrrr�r�classmethodr"r$r'r)r5r9r=r�rtr�r�r�r�r�rF�propertyr>rQrTr�r�r�r��
contextlib�contextmanagerr�r�rDr�r�r@r�r�r�r�r�r�r�r�r�r]r]r�r^rhs�



0&

��	�
G



	

N





)�	metaclass)NTN)r=r>r?r@rArBrCrDrErFr6rGrHrI)
r~rr9rFr7r�r�rrHr)r�rMrHrM)r])r�r�r�r�rHr�)r�r�r�r�r�r�rHrI)r�rFrHrI)W�
__future__r�__all__r�r�rM�loggingr�r�rgr�rrrr~�textwraprrnr�Z
git.compatr	r
rZgit.excrr
rrrZgit.utilrrrrrr�typingrrrrrrrrrr r!r"r#r$r%r&r'rQr*Ztyping_extensionsZ	git.typesr+r,r-Zgit.diffr.Z
git.repo.baser/r��	getLoggerr�rXr{r�rr�r|r�r�r�r�r�r�r�r�r��typer�rrr]r]r]r^�<module>sr L

�
�=

nm��

@ Telegram