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/repo/__pycache__/
Upload Files
File: //opt/saltstack/salt/lib/python3.10/site-packages/git/repo/__pycache__/base.cpython-310.pyc
o

;j���@s@ddlmZdgZddlZddlZddlZddlmZddl	m
Z
ddlZddlZddl
Z
ddlZddlZddlmZddlmZddlmZmZddlmZmZdd	lmZdd
lmZddlmZm Z m!Z!ddl"m#Z#dd
l$m%Z%m&Z&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:m;Z;m<Z<m=Z=ddl>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVddl>mWZWmXZXeQ�r
ddl$mYZYddlZm[Z[ddl\m]Z]ddl-m^Z^ddl1m_Z_e�`ea�ZbGdd�deN�ZcGdd�d�ZddS)�)�annotations�RepoN)�Path)�
LooseObjectDB)�	BadObject)�Git�handle_process_output)�defenc�safe_decode)�GitConfigParser)�GitCmdObjectDB)�GitCommandError�InvalidGitRepositoryError�NoSuchPathError��	IndexFile)�	Submodule�
RootModule�Commit)�HEAD�Head�	Reference�TagReference)�Remote�add_progress�to_progress_instance)�Actor�cygpath�expand_path�finalize_process�
hex_to_bin�remove_password_if_present�)�find_submodule_git_dir�find_worktree_git_dir�
is_git_dir�	rev_parse�touch)�CallableProgress�
Commit_ish�Lit_config_levels�PathLike�TBD�Tree_ish�assert_never)�Any�BinaryIO�Callable�Dict�Iterator�List�Mapping�
NamedTuple�Optional�Sequence�
TYPE_CHECKING�TextIO�Tuple�Type�Union�cast)�ConfigLevels_Tup�	TypedDict)�Tree)�UpdateProgress)�SymbolicReference)�RemoteProgress)�IterableListc@s.eZdZUded<ded<ded<ded<dS)	�
BlameEntryzDict[str, Commit]�commit�rangeZlinenos�
Optional[str]�	orig_pathZorig_linenosN��__name__�
__module__�__qualname__�__annotations__�rPrP�A/opt/saltstack/salt/lib/python3.10/site-packages/git/repo/base.pyrFbs

rFc@s�eZdZUdZdZedd�Zded<	dZded<ded	<	d
Z	ded<e
�d�Ze
�d
�Z
e
�d�Ze
�d�Ze
�d�Ze
�d�Zgd�Z	dZded<	eZ	deddf�dd d!�Z�d	d#d$�Z�d
d'd(�Z�dd)d*�Z�dd+d,�Z�dd/d0�Z�dd1d2�Z�d
d4d5�Ze�dd7d8��Z e j!�dd:d8��Z e�dd;d<��Z"e�dd=d>��Z#e�dd?d@��Z$e�ddBdC��Z%e�ddDdE��Z&e�ddGdH��Z'e�ddIdJ��Z(e�ddLdM��Z)e�ddOdP��Z*e�ddRdS��Z+�d�ddWdX�Z,e�ddZd[��Z-�dd]d^�Z.�ddadb�Z/�dddde�Z0�ddgdh�Z1e�ddjdk��Z2�d dmdn�Z3e4�d!dodp��Z5	q		�d"�d#dxdy�Z6�d$d|d}�Z7	q		�d%�d&d�d��Z8�d'd�d��Z9�d(d�d��Z:�d)d�d��Z;�d*�d+d�d��Z<	�d*�d,d�d��Z=		�d-�d.d�d��Z>�d/�d0d�d��Z?�d*�d1d�d��Z@�d2d�d��ZA�d*�d3d�d��ZB		
�d4�d5d�d��ZC�d6d�d��ZD�d7d�d��ZE�d*�d8d�d��ZF�dd�d��ZG�d9d�d��ZHe�dd�d���ZIeIj!�d9d�d���ZI�d:d�d��ZJ�d;d�dĄZKe�d:d�dƄ�ZLeLj!�d;d�dƄ�ZL					�d<�d=d�d̈́ZMe�d:d�dτ�ZN�d>d�dфZO�d?d�dӄZPe�d@d�dք�ZQ�dAd�dۄZR		�dB�dCd�d�ZSeTddedf�dDd�d��ZUeT				�dE�dFd�d��ZV				�dE�dGd�d�ZWeT					�dH�dId�d���ZX		�d-�dJd��d�ZY�d�d�d�ZZe[Z[�d�d�d�Z\�dK�d�d�Z]dS(Lra^Represents a git repository and allows you to query references, create commit
    information, generate diffs, create and clone repositories, and query the log.

    The following attributes are worth using:

    * :attr:`working_dir` is the working directory of the git command, which is the
      working tree directory if available or the ``.git`` directory in case of bare
      repositories.

    * :attr:`working_tree_dir` is the working tree directory, but will return ``None``
      if we are a bare repository.

    * :attr:`git_dir` is the ``.git`` repository directory, which is always set.
    zgit-daemon-export-okrNr+�working_dir�Optional[PathLike]�_working_tree_dir�git_dir��_common_dirz\s+z^[0-9A-Fa-f]{40}$z^[0-9A-Fa-f]{4,40}$z5(\$(\{\s?)?[a-zA-Z_]\w*(\}\s?)?|%\s?[a-zA-Z_]\w*\s?%)z^(author|committer)z^\t(.*)$)z
--upload-packz-uz--configz-c)�system�user�global�
repositoryr?�config_levelFT�path�odbt�Type[LooseObjectDB]�search_parent_directories�bool�expand_vars�return�NonecCs$|pt�d�}|s
t��}t�|�}t��rt|�}|r*t�|j	|�r*t
jddd�t||�}|dur=tj
�|�s=t|��|}d}|�rt�t�|d��r�t�t�|d��r�t�t�|d��r�|}d	tjvrmt�d	�|_n2tt�|d���}|����}	Wd�n1s�wYt�|	�s�t�t�||	��}	t�|	�|_nrt|�r�|}tj
�|�|_tj�d
�dur�|�d|�}
|
�dd
�r�|
�dd
�|_d	tjvr�t�d	�|_n>t�|d�}t|�}|dur�t�|�}t|�}|dur�t |�}|du�rt||�}||_n|�sn
t�!|�\}}
|
�sn|sD|du�rt"|��||_#d|_$z|�%d��&dd�|_$Wn
t'�y7Ynwzt(|j#�d�)��*�d��}t�|j#|�|_+Wn
t,�y^d|_+Ynw|j$�rfd|_|j�pl|j-|_.|�/|j.�|_0t�|j-d�}t1|t2��r�|||j0�|_3dS||�|_3dS)a�Create a new :class:`Repo` instance.

        :param path:
            The path to either the worktree directory or the .git directory itself::

                repo = Repo("/Users/mtrier/Development/git-python")
                repo = Repo("/Users/mtrier/Development/git-python.git")
                repo = Repo("~/Development/git-python.git")
                repo = Repo("$REPOSITORIES/Development/git-python.git")
                repo = Repo(R"C:\Users\mtrier\Development\git-python\.git")

            - In *Cygwin*, `path` may be a ``cygdrive/...`` prefixed path.
            - If `path` is ``None`` or an empty string, :envvar:`GIT_DIR` is used. If
              that environment variable is absent or empty, the current directory is
              used.

        :param odbt:
            Object DataBase type - a type which is constructed by providing the
            directory containing the database objects, i.e. ``.git/objects``. It will be
            used to access all object data.

        :param search_parent_directories:
            If ``True``, all parent directories will be searched for a valid repo as
            well.

            Please note that this was the default behaviour in older versions of
            GitPython, which is considered a bug though.

        :raise git.exc.InvalidGitRepositoryError:

        :raise git.exc.NoSuchPathError:

        :return:
            :class:`Repo`
        ZGIT_DIRzoThe use of environment variables in paths is deprecated
for security reasons and may be removed in the future!!r")�
stacklevelNZgitdirZ	commondirrZ
GIT_WORK_TREEZGIT_COMMON_DIRr[�coreZworktree�.gitF�barerrV�objects)4�os�getenv�getcwd�fspathr�	is_cygwinr�re�search�
re_envvars�warnings�warnrr]�existsr�osp�isfile�join�environrT�open�read�strip�isabs�normpath�dirnamer%�get�_config_readerZ
has_optionr#r$�splitrrU�_bare�
config_readerZ
getboolean�	Exceptionr�	read_text�
splitlinesrW�OSError�
common_dirrR�GitCommandWrapperType�git�
issubclassr�odb)�selfr]r^r`rbZepathZcurpathrU�fpZworktree_gitfileZgitconfZdotgitZ
sm_gitpath�tailr�ZrootpathrPrPrQ�__init__�s�+
�
���
�




�
E�
�z
Repo.__init__�'Repo'cCs|S�NrP�r�rPrPrQ�	__enter__VszRepo.__enter__�argsr/cGs|��dSr�)�close)r�r�rPrPrQ�__exit__Y�z
Repo.__exit__cCs$z|��WdStyYdSwr�)r�r�r�rPrPrQ�__del__\s
�zRepo.__del__cCsL|jr"|j��tjdkrt��tjj��tjdkr$t��dSdSdS)N�win32)	r��clear_cache�sys�platform�gcZcollect�gitdb�utilZmmanr�rPrPrQr�bs


�	z
Repo.close�rhs�objectcCst|t�r|j|jkSdS)NF)�
isinstancerrU�r�r�rPrPrQ�__eq__os
zRepo.__eq__cCs|�|�Sr�)r�r�rPrPrQ�__ne__tr�zRepo.__ne__�intcCs
t|j�Sr�)�hashrUr�rPrPrQ�__hash__ws
z
Repo.__hash__�strcCsNt�|jd�}t|d��}|�����t�Wd�S1s wYdS)zThe project's description�description�rbN)rurwrUryrz�rstrip�decoder	)r��filenamer�rPrPrQr�zs$�zRepo.description�descrcCsRt�|jd�}t|d��}|�|d�t��Wd�dS1s"wYdS)Nr��wb�
)rurwrUry�write�encoder	)r�r�r�r�rPrPrQr��s"�cC�|jS)z�
        :return:
            The working tree directory of our git repository.
            If this is a bare repository, ``None`` is returned.
        )rTr�rPrPrQ�working_tree_dir�szRepo.working_tree_dircCs|jp|jS)z�
        :return:
            The git dir that holds everything except possibly HEAD, FETCH_HEAD,
            ORIG_HEAD, COMMIT_EDITMSG, index, and logs/.
        )rWrUr�rPrPrQr��szRepo.common_dircCr�)z+:return: ``True`` if the repository is bare)r�r�rPrPrQrh�sz	Repo.bare�'IterableList[Head]'cC�
t�|�S)z�A list of :class:`~git.refs.head.Head` objects representing the branch heads
        in this repo.

        :return:
            ``git.IterableList(Head, ...)``
        )r�
list_itemsr�rPrPrQ�heads��
z
Repo.headscCr�)z�Alias for heads.
        A list of :class:`~git.refs.head.Head` objects representing the branch heads
        in this repo.

        :return:
            ``git.IterableList(Head, ...)``
        )r�r�rPrPrQ�branches��	z
Repo.branches�'IterableList[Reference]'cCr�)z�A list of :class:`~git.refs.reference.Reference` objects representing tags,
        heads and remote references.

        :return:
            ``git.IterableList(Reference, ...)``
        )rr�r�rPrPrQ�
references�r�zRepo.referencescCr�)z�Alias for references.
        A list of :class:`~git.refs.reference.Reference` objects representing tags,
        heads and remote references.

        :return:
            ``git.IterableList(Reference, ...)``
        )r�r�rPrPrQ�refs�r�z	Repo.refs�'IndexFile'cCst|�S)a6
        :return:
            A :class:`~git.index.base.IndexFile` representing this repository's index.

        :note:
            This property can be expensive, as the returned
            :class:`~git.index.base.IndexFile` will be reinitialized.
            It is recommended to reuse the object.
        rr�rPrPrQ�index�sz
Repo.index�'HEAD'cCs
t|d�S)zq
        :return:
            :class:`~git.refs.head.HEAD` object pointing to the current head reference
        r)rr�rPrPrQ�head�s
z	Repo.head�'IterableList[Remote]'cCr�)z�A list of :class:`~git.remote.Remote` objects allowing to access and
        manipulate remotes.

        :return:
            ``git.IterableList(Remote, ...)``
        )rr�r�rPrPrQ�remotes�r�zRepo.remotes�origin�name�'Remote'cCs"t||�}|��std|��|S)z�:return: The remote with the specified name

        :raise ValueError:
            If no remote with such a name exists.
        zRemote named '%s' didn't exist)rrt�
ValueError)r�r��rrPrPrQ�remote�s
zRepo.remote�'IterableList[Submodule]'cCr�)z�
        :return:
            git.IterableList(Submodule, ...) of direct submodules available from the
            current head
        )rr�r�rPrPrQ�
submodules�s
zRepo.submodules�'Submodule'c
Cs4z|j|WSty}ztd|�|�d}~ww)zx:return: The submodule with the given name

        :raise ValueError:
            If no such submodule exists.
        zDidn't find submodule named %rN)r��
IndexErrorr�)r�r��erPrPrQ�	submodule�s��zRepo.submodule�kwargsrcO�tj|g|�Ri|��S)aCreate a new submodule.

        :note:
            For a description of the applicable parameters, see the documentation of
            :meth:`Submodule.add <git.objects.submodule.base.Submodule.add>`.

        :return:
            The created submodule.
        )r�add�r�r�r�rPrPrQ�create_submodule	s
zRepo.create_submodule�Iterator[Submodule]cO�t|�j|i|��S)z�An iterator yielding Submodule instances.

        See the :class:`~git.objects.util.Traversable` interface for a description of `args`
        and `kwargs`.

        :return:
            Iterator
        )rZtraverser�rPrPrQ�iter_submoduless	zRepo.iter_submodulesrcOr�)a(Update the submodules, keeping the repository consistent as it will
        take the previous state into consideration.

        :note:
            For more information, please see the documentation of
            :meth:`RootModule.update <git.objects.submodule.root.RootModule.update>`.
        )r�updater�rPrPrQ�submodule_update szRepo.submodule_update�'IterableList[TagReference]'cCr�)z�A list of :class:`~git.refs.tag.TagReference` objects that are available in
        this repo.

        :return:
            ``git.IterableList(TagReference, ...)``
        )rr�r�rPrPrQ�tags,r�z	Repo.tagsrcCs|�|�}t||�S)a
        :return:
            :class:`~git.refs.tag.TagReference` object, reference pointing to a
            :class:`~git.objects.commit.Commit` or tag

        :param path:
            Path to the tag reference, e.g. ``0.1.5`` or ``tags/0.1.5``.
        )�_to_full_tag_pathr)r�r]�	full_pathrPrPrQ�tag6s
	
zRepo.tagcCsHt|�}|�tjd�r|S|�tjd�rtjd|Stjd|S)N�/)r��
startswithrZ_common_path_defaultZ_common_defaultr)r]Zpath_strrPrPrQr�BszRepo._to_full_tag_pathrrG�!Union['SymbolicReference', 'str']�force�logmsgrI�'Head'cCst�|||||�S)aCreate a new head within the repository.

        :note:
            For more documentation, please see the
            :meth:`Head.create <git.refs.head.Head.create>` method.

        :return:
            Newly created :class:`~git.refs.head.Head` Reference.
        )r�create)r�r]rGr�r�rPrPrQ�create_headLszRepo.create_headr��'Union[str, Head]'cOr�)z�Delete the given heads.

        :param kwargs:
            Additional keyword arguments to be passed to :manpage:`git-branch(1)`.
        )r�delete)r�r�r�rPrPrQ�delete_head^szRepo.delete_head�ref�Union[str, 'SymbolicReference']�messagecKstj|||||fi|��S)aCreate a new tag reference.

        :note:
            For more documentation, please see the
            :meth:`TagReference.create <git.refs.tag.TagReference.create>` method.

        :return:
            :class:`~git.refs.tag.TagReference` object
        )rr�)r�r]r�r�r�r�rPrPrQ�
create_tagfszRepo.create_tagr�cGstj|g|�R�S)z Delete the given tag references.)rr�)r�r�rPrPrQ�
delete_tagyszRepo.delete_tag�urlrcKstj|||fi|��S)z�Create a new remote.

        For more information, please see the documentation of the
        :meth:`Remote.create <git.remote.Remote.create>` method.

        :return:
            :class:`~git.remote.Remote` reference
        )rr�)r�r�r�r�rPrPrQ�
create_remote}s	zRepo.create_remoter�cCst�||�S)zDelete the given remote.)r�remove)r�r�rPrPrQ�
delete_remote�szRepo.delete_remoter*c	Cs�|dur|j}tjdkr|dkrd}|dkrdS|dkr:tj�d�p,t�tj�dd�d	�}t�t�	t�|d
d���S|dkrFt�t�	d��S|d
kr\|j
pN|}|sSt�t�t�|d��St|t
d|����dS)Nr�rXrZz/etc/gitconfigrYZXDG_CONFIG_HOME�HOME�~z.configr�Zconfigz~/.gitconfigr[zInvalid configuration level: )rUr�r�rjrxrrurwr}�
expanduserrW�NotADirectoryErrorr.r�)r�r\rUZconfig_homeZrepo_dirrPrPrQ�_get_config_path�s("
�zRepo._get_config_path�Optional[Lit_config_levels]rcCs|j|d�S)a�
        :return:
            :class:`~git.config.GitConfigParser` allowing to read the full git
            configuration, but not to write it.

            The configuration will include values from the system, user and repository
            configuration files.

        :param config_level:
            For possible values, see the :meth:`config_writer` method. If ``None``, all
            applicable levels will be used. Specify a level in case you know which file
            you wish to read to prevent reading multiple files.

        :note:
            On Windows, system configuration cannot currently be read as the path is
            unknown, instead the global path will be used.
        )r\)r��r�r\rPrPrQr��szRepo.config_readercs<|dur��fdd��jD�}n��|��g}t|d�d�S)Ncsg|]
}|r��|���qSrP)r�)�.0�f�rUr�rPrQ�
<listcomp>�sz'Repo._config_reader.<locals>.<listcomp>T)�	read_only�repo)r\r�r)r�r\rU�filesrPr�rQr��szRepo._config_readerr[cCst|�|�d|dd�S)au
        :return:
            A :class:`~git.config.GitConfigParser` allowing to write values of the
            specified configuration file level. Config writers should be retrieved, used
            to change the configuration, and written right away as they will lock the
            configuration file in question and prevent other's to write it.

        :param config_level:
            One of the following values:

            * ``"system"`` = system wide configuration file
            * ``"global"`` = user level configuration file
            * ``"`repository"`` = configuration file for this repository only
        F)rrZmerge_includes)rr�r�rPrPrQ�
config_writer�szRepo.config_writer�rev�Union[str, Commit_ish, None]rcCs"|dur|jjS|�t|�d�S)z�The :class:`~git.objects.commit.Commit` object for the specified revision.

        :param rev:
            Revision specifier, see :manpage:`git-rev-parse(1)` for viable options.

        :return:
            :class:`~git.objects.commit.Commit`
        Nz^0)r�rGr&r��r�rrPrPrQrG�s	zRepo.commit�Iterator['Tree']cOsdd�|j|i|��D�S)z�:return: Iterator yielding :class:`~git.objects.tree.Tree` objects

        :note:
            Accepts all arguments known to the :meth:`iter_commits` method.
        css�|]}|jVqdSr�)�tree)r��crPrPrQ�	<genexpr>�s�z"Repo.iter_trees.<locals>.<genexpr>)�iter_commitsr�rPrPrQ�
iter_trees�szRepo.iter_trees�Union[Tree_ish, str, None]�'Tree'cCs$|dur	|jjjS|�t|�d�S)a&The :class:`~git.objects.tree.Tree` object for the given tree-ish revision.

        Examples::

              repo.tree(repo.heads[0])

        :param rev:
            A revision pointing to a Treeish (being a commit or tree).

        :return:
            :class:`~git.objects.tree.Tree`

        :note:
            If you need a non-root level tree, find it by iterating the root tree.
            Otherwise it cannot know about its path relative to the repository root and
            subsequent operations might have unexpected results.
        Nz^{tree})r�rGr	r&r�rrPrPrQr	�s
z	Repo.tree�-Union[str, Commit, 'SymbolicReference', None]�paths�#Union[PathLike, Sequence[PathLike]]�Iterator[Commit]cKs&|dur|jj}tj|||fi|��S)a*An iterator of :class:`~git.objects.commit.Commit` objects representing the
        history of a given ref/commit.

        :param rev:
            Revision specifier, see :manpage:`git-rev-parse(1)` for viable options.
            If ``None``, the active branch will be used.

        :param paths:
            An optional path or a list of paths. If set, only commits that include the
            path or paths will be returned.

        :param kwargs:
            Arguments to be passed to :manpage:`git-rev-list(1)`.
            Common ones are ``max_count`` and ``skip``.

        :note:
            To receive only commits between two named revisions, use the
            ``"revA...revB"`` revision specifier.

        :return:
            Iterator of :class:`~git.objects.commit.Commit` objects
        N)r�rGrZ
iter_items)r�rrr�rPrPrQrszRepo.iter_commitsr,�List[Commit]c
Os�t|�dkrtdt|���g}z
|jj|i|����}Wnty7}z|jdkr+�|WYd}~Sd}~ww|D]
}|�|�|��q:|S)aFind the closest common ancestor for the given revision
        (:class:`~git.objects.commit.Commit`\s, :class:`~git.refs.tag.Tag`\s,
        :class:`~git.refs.reference.Reference`\s, etc.).

        :param rev:
            At least two revs to find the common ancestor for.

        :param kwargs:
            Additional arguments to be passed to the ``repo.git.merge_base()`` command
            which does all the work.

        :return:
            A list of :class:`~git.objects.commit.Commit` objects. If ``--all`` was
            not passed as a keyword argument, the list will have at max one
            :class:`~git.objects.commit.Commit`, or is empty if no common merge base
            exists.

        :raise ValueError:
            If fewer than two revisions are provided.
        �z-Please specify at least two revs, got only %i�N)	�lenr�r��
merge_baser�r
�status�appendrG)r�rr��res�lines�err�linerPrPrQr&s
��	zRepo.merge_base�ancestor_revc
CsLz|jj||dd�WdSty%}z
|jdkr WYd}~dS�d}~ww)aCheck if a commit is an ancestor of another.

        :param ancestor_rev:
            Rev which should be an ancestor.

        :param rev:
            Rev to test against `ancestor_rev`.

        :return:
            ``True`` if `ancestor_rev` is an ancestor to `rev`.
        T)�is_ancestorr"NF)r�rr
r)r�rrrrPrPrQr Qs�
��zRepo.is_ancestor�sha�object_type�Union[str, None]cCspz(|j�|�}|j�|�}|r&|j|��krWdSt�d|j��|�WdSWdSty7t�d�YdSw)NTzQCommit hash points to an object of type '%s'. Requested were objects of type '%s'FzCommit hash is invalid.)	r�Zpartial_to_complete_sha_hex�info�typer��_logger�debugr�r)r�r!r"Zcomplete_shaZobject_inforPrPrQ�is_valid_objectes"�
�zRepo.is_valid_objectcCs |jrt�|j|j�}t�|�Sr�)rUrurw�DAEMON_EXPORT_FILErt)r�r�rPrPrQ�_get_daemon_exportys
zRepo._get_daemon_export�valuecCsR|jrt�|j|j�}t�|�}|r|st|�dS|s%|r't�|�dSdSdSr�)rUrurwr)rtr'rj�unlink)r�r+r�Z
fileexistsrPrPrQ�_set_daemon_export~s
�zRepo._set_daemon_exportcC�|��S)z.If True, git-daemon may export this repository)r*r�rPrPrQ�
daemon_export��zRepo.daemon_exportcC�|�|�dSr�)r-)r�r+rPrPrQr/���	List[str]cCsj|jrt�|jddd�}t�|�r3t|d��}|���t�}Wd�n1s(wY|���	�SgS)z�The list of alternates for this repo from which objects can be retrieved.

        :return:
            List of strings being pathnames of alternates
        rir$�
alternatesr�N)
rUrurwrtryrzr�r	r{r�)r��alternates_pathr��altsrPrPrQ�_get_alternates�s
�zRepo._get_alternatesr6cCsxt�|jddd�}|st�|�rt�|�dSdSt|d��}|�d�|��t	��Wd�dS1s5wYdS)a�Set the alternates.

        :param alts:
            The array of string paths representing the alternates at which git should
            look for objects, i.e. ``/home/user/repo/.git/objects``.

        :raise git.exc.NoSuchPathError:

        :note:
            The method does not check for the existence of the paths in `alts`, as the
            caller is responsible.
        rir$r4r�r�N)
rurwr�rvrjr�ryr�r�r	)r�r6r5r�rPrPrQ�_set_alternates�s

�"�zRepo._set_alternatescCr.)zPRetrieve a list of alternates paths or set a list paths to be used as alternates)r7r�rPrPrQr4�r0zRepo.alternatescCr1r�)r8)r�r6rPrPrQr4�r2r��working_tree�untracked_filesr�cCs�|jrdSgd�}|s|�d�|r|�dt�|�g�|r3t�|jj�r3t	|j
jdg|�R��r3dS|r?t	|j
j|��r?dS|rMt	|j||d��rMdSdS)a
        :return:
            ``True`` if the repository is considered dirty. By default it will react
            like a :manpage:`git-status(1)` without untracked files, hence it is dirty
            if the index or the working copy have changes.
        F)z--abbrev=40z--full-indexz--rawz--ignore-submodules�--z--cachedT)Zignore_submodules)
r�r�extendrjrmrurvr�r]rr��diff�_get_untracked_files)r�r�r9r:r�r]Zdefault_argsrPrPrQ�is_dirty�s"
&z
Repo.is_dirtycCr.)a�
        :return:
            list(str,...)

            Files currently untracked as they have not been staged yet. Paths are
            relative to the current working directory of the git command.

        :note:
            Ignored files will not appear here, i.e. files mentioned in ``.gitignore``.

        :note:
            This property is expensive, as no cache is involved. To process the result,
            please consider caching it yourself.
        )r>r�rPrPrQr:�szRepo.untracked_filescOs�|jj|dddd�|��}d}g}|jD]A}|�t�}|�|�s!q|t|�d��d�}|d|dkr:dkrPnn|dd�}|�d	��d
��d��t�}|�	|�qt
|�|S)NT)Z	porcelainr:�
as_processz?? r�r����"r"�asciiZunicode_escape�latin1)r�r�stdoutr�r	r�rr�r�rr)r�r�r��proc�prefixr:rr�rPrPrQr>�s


 zRepo._get_untracked_filesc
Gs`z|jj|�}Wnty"}z|jdkrgWYd}~S�d}~ww|�dd��dd��d�S)a Checks if paths are ignored via ``.gitignore``.

        This does so using the :manpage:`git-check-ignore(1)` method.

        :param paths:
            List of paths to check whether they are ignored or not.

        :return:
            Subset of those paths which are ignored
        r"Nz\\�\rBrVr�)r�Zcheck_ignorer
r�replacer�)r�rrFrrPrPrQ�ignoreds
��	zRepo.ignoredrcCs|jj}|jdkr
td��|S)aRThe name of the currently active branch.

        :raise TypeError:
            If HEAD is detached.

        :raise ValueError:
            If HEAD points to the ``.invalid`` ref Git uses to mark refs as
            incompatible with older clients.

        :return:
            :class:`~git.refs.head.Head` to the active branch
        z.invalidzdHEAD points to 'refs/heads/.invalid', which Git uses to mark refs as incompatible with older clients)r�Z	referencer�r�)r��
active_branchrPrPrQrK$s
�zRepo.active_branch�str | HEAD | None�file�Iterator['BlameEntry']cks��|jj|d|fdddd�|��}i}dd�|�d�D�}	zt|�}Wn
ty.YdSw|��}|\}	}
}}t|�}
t|�}t|
�}|	|vr�i}	zt|�}Wn
ty\YdSw|d	krbqK|�d
d�\}}|||<|dkru|}nqLt|t|	�tt	|d
�t	|d�
d��d���t|d�tt	|d�t	|d�
d��d���t|d�d�}|||	<n"	zt|�}Wn
ty�YdSw|�d
d�\}}|dkr�|}nq�t||	t
|
|
|�t	|�t
|||��Vq)aBIterator for blame information for the given file at the given revision.

        Unlike :meth:`blame`, this does not return the actual file's contents, only a
        stream of :class:`BlameEntry` tuples.

        :param rev:
            Revision specifier. If ``None``, the blame will include all the latest
            uncommitted changes. Otherwise, anything successfully parsed by
            :manpage:`git-rev-parse(1)` is a valid option.

        :return:
            Lazy iterator of :class:`BlameEntry` tuples, where the commit indicates the
            commit to blame for the line, and range indicates a span of line numbers in
            the resulting file.

        If you combine all line number ranges outputted by this command, you should get
        a continuous range spanning all line numbers in the file.
        r;TF)�p�incremental�stdout_as_stringcss�|]}|r|VqdSr�rP)r�rrPrPrQrPs�z)Repo.blame_incremental.<locals>.<genexpr>�
Nsboundary� r"sfilenamesauthorsauthor-mail�<�>sauthor-times	committerscommitter-mailscommitter-time��authorZ
authored_date�	committerZcommitted_date)r��blamer��next�
StopIterationr�rr rr
�lstripr�rFrH)r�rrMr��data�commits�streamrZ
split_lineZhexshaZ
orig_lineno_bZlineno_bZnum_lines_b�linenoZ	num_linesZorig_linenoZpropsr�r+Z
orig_filenamer
rPrPrQ�blame_incremental9s�� ���
�

�
�
����zRepo.blame_incremental�Union[str, HEAD, None]rP�rev_opts�Optional[List[str]]�KList[List[Commit | List[str | bytes] | None]] | Iterator[BlameEntry] | NonecKs|r|j||fi|��S|pg}|jj|g|�d�|�Rddd�|��}i}g}Gdd�dtdd�}	i}
d}|�|�D�]K}z	|���t�}
WntyVd}g}d}Ynw|j	�
|
d	�}|d
}d}|j�|�r�|d�
d�}t
|�d
kr�d|i}
|�dgg�q;|
d|kr�d|i}
|�|�|�gg�q;|j�|�}|r�|�d
�}|dkr�|�d�r�|d|
d<q;|�d�r�t|d�|
d<q;||kr�|d|
d<q;|dkr�|�d�r�|d|
d<q;|�d�r�t|d�|
d<q;||kr�|d|
d<q;|�d��r|d|
d<q;|�d��r|d|
d<q;|dk�r�|
�r�|
d}|�|�}|du�rSt|t|�t�|
d�d|
d���|
dt�|
d�d|
d���|
dd�}|||<||dd
<|dd	du�r�|�sx|
�ru|
d
dk�ru|
d	d�}
|
}n|}|dd	�|�d|i}
q;|S)a�The blame information for the given file at the given revision.

        :param rev:
            Revision specifier. If ``None``, the blame will include all the latest
            uncommitted changes. Otherwise, anything successfully parsed by
            :manpage:`git-rev-parse(1)` is a valid option.

        :return:
            list: [git.Commit, list: [<line>]]

            A list of lists associating a :class:`~git.objects.commit.Commit` object
            with a list of lines that changed within the given commit. The
            :class:`~git.objects.commit.Commit` objects will be given in order of
            appearance.
        r;TF)rOrQc@s^eZdZUded<ded<ded<ded<ded<ded<ded	<ded
<ded<ded<d
S)zRepo.blame.<locals>.InfoTDr�r!�idr��summaryrW�author_emailr��author_daterX�committer_email�committer_dateNrKrPrPrPrQ�InfoTD�s
rl)�totalrVr"rrA� �rfNrWz-mailrhz-timerirXrjrkr�rgrV�	)rar�rYr@r�r�r�r	�UnicodeDecodeError�
re_whitespacer��re_hexsha_onlyrprrr�re_author_committer_start�group�endswithr�r�rr rZ_from_string)r�rrMrPrcr�r]r^Zblamesrlr$�keependsZ
line_bytesZline_strZ	firstpart�partsZ	is_binary�digits�mZroler!r
rrPrPrQrY�s�(�
�



�

�


��z
Repo.blame�Union[PathLike, None]�mkdir�Type[GitCmdObjectDB]cKsR|rt||�}|r|rt�|�st�|d�|�|�}|jdi|��|||d�S)a�Initialize a git repository at the given path if specified.

        :param path:
            The full path to the repo (traditionally ends with ``/<name>.git``). Or
            ``None``, in which case the repository will be created in the current
            working directory.

        :param mkdir:
            If specified, will create the repository directory if it doesn't already
            exist. Creates the directory with a mode=0755.
            Only effective if a path is explicitly given.

        :param odbt:
            Object DataBase type - a type which is constructed by providing the
            directory containing the database objects, i.e. ``.git/objects``. It will be
            used to access all object data.

        :param expand_vars:
            If specified, environment variables will not be escaped. This can lead to
            information disclosure, allowing attackers to access the contents of
            environment variables.

        :param kwargs:
            Keyword arguments serving as additional options to the
            :manpage:`git-init(1)` command.

        :return:
            :class:`Repo` (the newly created repo)
        i��r^NrP)rrurtrj�makedirsr��init)�clsr]r|r^rbr�r�rPrPrQr�.s&

z	Repo.initr��'Git'�odb_default_type�progress�PUnion['RemoteProgress', 'UpdateProgress', Callable[..., 'RemoteProgress'], None]�
multi_options�allow_unsafe_protocols�allow_unsafe_optionsc	Ks�|	�d|�}
t�|�}t�|�}t��rd|	vrt�|�n|}|	�d�}|r-t�|�|	d<d}
|r9t�d�	|��}
|s@t�
|�|sNtjt|	�
��|jd�|sZ|
rZtj|
|jd�|j|
dt�|�|fddddd�t|	||���}|r�t|dt|���td	d
�n|��\}}t|dd�}t|�}t�d
||�t||d�t�|�s�|jdur�t�	|j|�n|}|||
d�}|jjdi|����|j r�|j dj!�}|�"dt�|j dj#��Wd�|S1s�wY|S)Nr^rhZseparate_git_dirrn)�optionsZunsafe_optionsr;T)Zwith_extended_outputr@�v�universal_newlinesF)Zdecode_streamsr�rVzCmd(%s)'s unused stdout: %s)�stderrr~rr�rP)$�poprjrmrrnZ
polish_urlr�shlexr�rwZcheck_unsafe_protocolsZcheck_unsafe_options�list�keys�unsafe_git_clone_options�clonerrrZnew_message_handlerr�communicate�getattrr!r&r'rur|Z_working_dirr��update_environmentZenvironmentr�rZ	set_valuer�)r�r�r�r]r�r�r�r�r�r�r^Z
clone_pathZsep_dirZmultirFrEr�Zcmdliner�writerrPrPrQ�_clone^sj



��
	�
�

��zRepo._clone�Optional[CallableProgress]cKs,|j|j|j|t|j�||f||d�|��S)aCreate a clone from this repository.

        :param path:
            The full path of the new repo (traditionally ends with ``./<name>.git``).

        :param progress:
            See :meth:`Remote.push <git.remote.Remote.push>`.

        :param multi_options:
            A list of :manpage:`git-clone(1)` options that can be provided multiple
            times.

            One option per list item which is passed exactly as specified to clone.
            For example::

                [
                    "--config core.filemode=false",
                    "--config core.ignorecase",
                    "--recurse-submodule=repo1_path",
                    "--recurse-submodule=repo2_path",
                ]

        :param allow_unsafe_protocols:
            Allow unsafe protocols to be used, like ``ext``.

        :param allow_unsafe_options:
            Allow unsafe options to be used, like ``--upload-pack``.

        :param kwargs:
            * ``odbt`` = ObjectDatabase Type, allowing to determine the object database
              implementation used by the returned :class:`Repo` instance.
            * All remaining keyword arguments are given to the :manpage:`git-clone(1)`
              command.

        :return:
            :class:`Repo` (the newly cloned repo)
        �r�r�)r�r�r�r%r�)r�r]r�r�r�r�r�rPrPrQr��s.��	�z
Repo.clone�to_pathr(�env�Optional[Mapping[str, str]]c
KsH|�t���}	|dur|	jdi|��|j|	||t||f||d�|��S)a�Create a clone from the given URL.

        :param url:
            Valid git url, see: https://git-scm.com/docs/git-clone#URLS

        :param to_path:
            Path to which the repository should be cloned to.

        :param progress:
            See :meth:`Remote.push <git.remote.Remote.push>`.

        :param env:
            Optional dictionary containing the desired environment variables.

            Note: Provided variables will be used to update the execution environment
            for ``git``. If some variable is not specified in `env` and is defined in
            :attr:`os.environ`, value from :attr:`os.environ` will be used. If you want
            to unset some variable, consider providing empty string as its value.

        :param multi_options:
            See the :meth:`clone` method.

        :param allow_unsafe_protocols:
            Allow unsafe protocols to be used, like ``ext``.

        :param allow_unsafe_options:
            Allow unsafe options to be used, like ``--upload-pack``.

        :param kwargs:
            See the :meth:`clone` method.

        :return:
            :class:`Repo` instance pointing to the cloned directory.
        Nr�rP)r�rjrlr�r�r)
r�r�r�r�r�r�r�r�r�r�rPrPrQ�
clone_from�s .��	�zRepo.clone_from�ostream�Union[TextIO, BinaryIO]�treeishrGcKs�|dur|jj}|rd|vr||d<||d<|�dg�}tttttttdff|�}t|t	t
f�s6|g}|jjd|g|�Ri|��|S)a�Archive the tree at the given revision.

        :param ostream:
            File-compatible stream object to which the archive will be written as bytes.

        :param treeish:
            The treeish name/id, defaults to active branch.

        :param prefix:
            The optional prefix to prepend to each filename in the archive.

        :param kwargs:
            Additional arguments passed to :manpage:`git-archive(1)`:

            * Use the ``format`` argument to define the kind of format. Use specialized
              ostreams to write any format supported by Python.
            * You may specify the special ``path`` keyword, which may either be a
              repository-relative path to a directory or file to place into the archive,
              or a list or tuple of multiple paths.

        :raise git.exc.GitCommandError:
            If something went wrong.

        :return:
            self
        NrGZ
output_streamr].r;)
r�rGr�r>r=r+r4r;r��tupler�r��archive)r�r�r�rGr�r]rPrPrQr�,s! zRepo.archivecCs(|jrdS|jrt�t�|jd��SdS)ai
        :return:
            True if our :attr:`git_dir` is not at the root of our
            :attr:`working_tree_dir`, but a ``.git`` file with a platform-agnostic
            symbolic link. Our :attr:`git_dir` will be wherever the ``.git`` file points
            to.

        :note:
            Bare repositories will always return ``False`` here.
        Frg)rhr�rurvrwr�rPrPrQ�has_separate_working_treeZs
zRepo.has_separate_working_treecCs|j}d|j|j|jfS)Nz
<%s.%s %r>)�	__class__rMrLrU)r�ZclazzrPrPrQ�__repr__nsz
Repo.__repr__�
Commit | NonecCsb|jr
t�|jd�}t�|�sdSt|d��}|����}Wd�n1s'wY|�|�S)z�
        :return:
            The commit which is currently being replayed while rebasing.

            ``None`` if we are not currently rebasing.
        ZREBASE_HEADNZrt)rUrurwrvry�readliner{rG)r�Zrebase_head_filer��contentrPrPrQ�currently_rebasing_onrs
�
zRepo.currently_rebasing_on)
r]rSr^r_r`rarbrarcrd)rcr�)r�r/rcrd)rcrd)r�r�rcra)rcr�)rcr�)r�r�rcrd)rcrS)rcr+)rcra)rcr�)rcr�)rcr�)rcr�)rcr�)r�)r�r�rcr�)rcr�)r�r�rcr�)r�r/r�r/rcr)r�r/r�r/rcr�)r�r/r�r/rcr)rcr�)r]r+rcr)r]r+rcr�)rFN)
r]r+rGr�r�rar�rIrcr�)r�r�r�r/rcrd)rNF)r]r+r�r�r�rIr�rar�r/rcr)r�rrcrd)r�r�r�r�r�r/rcr)r�r�rcr�r�)r\r*rUrSrcr�)r\r�rcr)NN)r\r�rUrSrcr)r[)r\r*rcr)rrrcr)r�r/r�r/rcr)rrrcr)NrV)rrrrr�r/rcr)rr,r�r/rcr)rrrrrcra)r!r�r"r#rcra)r+r�rcrd)rcr3)r6r3rcrd)TTFTN)r�rar9rar:rar�rar]rSrcra)r�r/r�r/rcr3)rr+rcr3)rcr)rrLrMr�r�r/rcrN)FN)rrbrMr�rPrarcrdr�r/rcre)r]r{r|rar^r}rbrar�r/rcr�)NNFF)r�r�r�r+r]r+r�r}r�r�r�rdr�rar�rar�r/rcr�)r]r+r�r�r�rdr�rar�rar�r/rcr�)NNNFF)r�r+r�r+r�r(r�r�r�rdr�rar�rar�r/rcr�)
r�r�r�rIrGrIr�r/rcr)rcr�)^rLrMrN�__doc__r)r>r�rOrTrWro�compilerrrsZre_hexsha_shortenedrqrtZre_tab_full_liner�r\rr�rr�r�r�r�r�r�r�r��propertyr��setterr�r�rhr�r�r�r�r�r�r�r�r�r�r�r�r�r�r��staticmethodr�r�r�r�r�r�r�r�r�r�rrGr
r	rrr r(r*r-r/r7r8r4r?r:r>rJrKrarY�classmethodr�r�r�r�r�r�r&r�r�rPrPrPrQris>







�*
	
	
	
	����
�!+	�)`��/�Y�:�?�.)e�
__future__r�__all__r��loggingrjZos.pathr]ru�pathlibrror�r�rrr�Zgitdb.db.looserZ	gitdb.excrZgit.cmdrrZ
git.compatr	r
Z
git.configrZgit.dbrZgit.excr
rrZ	git.indexrZgit.objectsrrrZgit.refsrrrrZ
git.remoterrrZgit.utilrrrrr r!Zfunr#r$r%r&r'Z	git.typesr(r)r*r+r,r-r.�typingr/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rAZgit.objects.submodule.baserBZgit.refs.symbolicrCrDrE�	getLoggerrLr&rFrrPrPrPrQ�<module>sJ 	$
H	

@ Telegram