AlkantarClanX12

Your IP : 3.14.251.103


Current Path : /opt/cloudlinux/venv/lib64/python3.11/site-packages/git/repo/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib64/python3.11/site-packages/git/repo/__pycache__/base.cpython-311.pyc

�

�܋f-���f�ddlmZddlZddlZddlZddlZddlZddlmZddl	m
Z
ddlmZddl
mZmZddlmZmZmZddlmZdd	lmZdd
lmZmZmZddlmZddlmZm Z m!Z!dd
l"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1ddl2m3Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;Z;ddl<Z<ddl=m>Z>m?Z?m@Z@mAZAmBZBmCZCddlDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTddl=mUZUmVZVeTrddl+mWZWddlXmYZYddlmZZZddl[m\Z\ddl'm]Z]ej^e_��Z`dZaGd�deR��ZbGd�dec��ZddS)�)�annotationsN)�Path)�
LooseObjectDB)�	BadObject)�Git�handle_process_output)�defenc�safe_decode�is_win)�GitConfigParser)�GitCmdObjectDB)�GitCommandError�InvalidGitRepositoryError�NoSuchPathError��	IndexFile)�	Submodule�
RootModule�Commit)�HEAD�Head�	Reference�TagReference)�Remote�add_progress�to_progress_instance)�Actor�finalize_process�cygpath�
hex_to_bin�expand_path�remove_password_if_present�)�	rev_parse�
is_git_dir�find_submodule_git_dir�touch�find_worktree_git_dir)�TBD�PathLike�Lit_config_levels�
Commit_ish�Tree_ish�assert_never)�Any�BinaryIO�Callable�Dict�Iterator�List�Mapping�Optional�Sequence�TextIO�Tuple�Type�Union�
NamedTuple�cast�
TYPE_CHECKING)�ConfigLevels_Tup�	TypedDict)�IterableList)�SymbolicReference)�Tree)�UpdateProgress)�RemoteProgress)�Repoc�8�eZdZUded<ded<ded<ded<dS)	�
BlameEntryzDict[str, 'Commit']�commit�range�linenos�
Optional[str]�	orig_path�orig_linenosN��__name__�
__module__�__qualname__�__annotations__���^/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/git/repo/base.pyrHrHes?������������N�N�N����������rUrHc��eZdZUdZdZedd��Zded<dZded<ded	<d
Z	ded<e
jd��Ze
jd
��Z
e
jd��Ze
jd��Ze
jd��Ze
jd��Zgd�ZdZded<eZdeddfd�d �Zd�d"�Zd�d%�Zd�d&�Zd�d'�Zd�d*�Zd�d+�Zd�d-�Zd�d/�Zd�d1�Z e!ee d2�3��Z"[[ e!d�d4���Z#e!d�d5���Z$e!d�d6���Z%e!d�d8���Z&e!d�d:���Z'e'Z(e&Z)e!d�d<���Z*e!d�d>���Z+e!d�d@���Z,d�d�dD�Z-e!d�dF���Z.d�dH�Z/d�dK�Z0d�dM�Z1d�dN�Z2e!d�dP���Z3d�dR�Z4e5d�dS���Z6			d�d�d[�Z7d�d^�Z8			d�d�db�Z9d�dd�Z:d�dg�Z;d�di�Z<d�d�dk�Z=	d�d�dn�Z>		d�d�do�Z?d�d�dq�Z@d�d�du�ZAd�dw�ZBd�d�dz�ZC		d�d�d�ZDd�d��ZEd�d��ZFd�d�d��ZGd�d��ZHd�d��ZIe!eHeId��3��ZJ[H[Id�d��ZKd�d��ZLe!eKeLd��3��ZM					d�d�d��ZNe!d�d����ZOd�d��ZPd�d��ZQe!d�d����ZRd�d��ZS		d�d�d��ZTeUddedfd�d����ZVeU				d��dd����ZW				d��dd��ZXeU					�d�dd����ZY		d�dd��ZZd�d��Z[e\Z\d�d��Z]�dd„Z^dS(rFa)Represents a git repository and allows you to query references,
    gather commit information, generate diffs, create and clone repositories query
    the log.

    The following attributes are worth using:

    '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

    'working_tree_dir' is the working tree directory, but will return None
    if we are a bare repository.

    '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�Nonec��|ptjd��}|stj��}tj��rt|��}|p|ptj��}t
|t��st|��}|r.tj	|j
|��rtjd��t||��}|�.tj�|��st!|���|}d}|�rWt#|��r�|}tj�|��|_tj�d���G|�d|��}|�dd��r|�dd��|_dtjvrtjd��|_n�t1j|d	��}	t5|	��}
|
�t1j|
��}t5|	��}
|
�t9|	��}
|
�t|
|��}||_n |snt1j|��\}}|sn|��W|�t=|���||_d
|_ 	|�!d���"dd��|_ n#tF$rYnwxYw	tI|j��dz�%���&��d
�'��}t1j|j|��|_(n#tR$r
d|_(YnwxYw|j rd|_|jp|j*|_+|�,|j+��|_-t1j|j*d��}
t]|t^��r||
|j-��|_0dS||
��|_0dS)a	Create a new Repo instance

        :param path:
            the path to either the root git directory or the bare git repo::

                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("C:\Users\mtrier\Development\git-python\.git")

            - In *Cygwin*, path may be a `'cygdrive/...'` prefixed path.
            - If it evaluates to false, :envvar:`GIT_DIR` is used, and if this also evals to false,
              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 InvalidGitRepositoryError:
        :raise NoSuchPathError:
        :return: git.Repo�GIT_DIRzoThe use of environment variables in paths is deprecated
for security reasons and may be removed in the future!!N�GIT_COMMON_DIRra�core�worktree�
GIT_WORK_TREE�.gitF�bare�	commondirrr\�objects)1�os�getenv�getcwdr�	is_cygwinr�
isinstance�str�re�search�
re_envvars�warnings�warnr!rc�existsrr%�dirnamerZ�environ�get�_config_reader�
has_option�osp�joinr&�normpathr(�splitrr[�_bare�
config_reader�
getboolean�	Exceptionr�	read_text�
splitlines�stripr]�OSError�
common_dirrX�GitCommandWrapperType�git�
issubclassr
�odb)�selfrcrdrfrh�epath�curpathr[�gitconf�dotgit�
sm_gitpath�tailr��rootpaths              rV�__init__z
Repo.__init__�s���D�,��	�)�,�,���	 ��I�K�K�E��=�?�?�	#��E�N�N�E��,��,�������%��%�%�	���J�J�E��	�2�9�T�_�e�<�<�	��M�N�
�
�
��E�;�/�/�����7�>�>�%�(�(�
-�%�e�,�,�,������*	�
�'�"�"�
�!��*,�����)A�)A��&��:�>�>�"2�3�3�;�"�1�1�,��H�H�G��)�)�&�*�=�=�Q�18���V�Z�1P�1P��.�"�b�j�0�0�-/�Y��-G�-G�D�*���X�g�v�.�.�F�/��7�7�J��%��,�z�2�2��/��7�7�J��!�2�6�:�:�
��%�%�j�+�>�>��)0��&��,�
���I�g�.�.�M�G�T��
��U�*	�Z�?�+�E�2�2�2������
�	��+�+�L�9�9�D�D�V�V�T�T�D�J�J���	�	�	��D�	����	"��t�|�,�,�{�:�E�E�G�G�R�R�T�T�UV�W�]�]�_�_�J�"�x���j�A�A�D�����	"�	"�	"�!�D����	"����
�:�	*�%)�D�"�&*�%;�%N�t�����-�-�d�.>�?�?����8�D�O�Y�7�7���d�N�+�+�	&��t�H�d�h�/�/�D�H�H�H��t�H�~�~�D�H�H�Hs%�7.J&�&
J3�2J3�7A2L*�*L>�=L>�'Repo'c��|S�NrT�r�s rV�	__enter__zRepo.__enter__)s���rU�argsr/c�.�|���dSr�)�close)r�r�s  rV�__exit__z
Repo.__exit__,s���
�
�����rUc�R�	|���dS#t$rYdSwxYwr�)r�r�r�s rV�__del__zRepo.__del__/s:��	��J�J�L�L�L�L�L���	�	�	��D�D�	���s��
&�&c��|jrr|j���trtj��t
jj���trtj��dSdSdSr�)r��clear_cacher�gc�collect�gitdb�util�mmanr�s rVr�z
Repo.close5sv���8�	��H� � �"�"�"��
��
�����J�O�#�#�%�%�%��
��
������	�	�
�
rU�rhs�objectc�P�t|t��r|j|jkSdS)NF)ryrFr[�r�r�s  rV�__eq__zRepo.__eq__Ds(���c�4� � �	/��<�3�;�.�.��urUc�.�|�|��Sr�)r�r�s  rV�__ne__zRepo.__ne__Is���;�;�s�#�#�#�#rU�intc�*�t|j��Sr�)�hashr[r�s rV�__hash__z
Repo.__hash__Ls���D�L�!�!�!rUrzc��tj|jd��}t|d��5}|�������t��cddd��S#1swxYwYdS)N�description�rb)r�r�r[�open�read�rstrip�decoder	)r��filename�fps   rV�_get_descriptionzRepo._get_descriptionPs����8�D�L�-�8�8��
�(�D�
!�
!�	5�R��7�7�9�9�#�#�%�%�,�,�V�4�4�	5�	5�	5�	5�	5�	5�	5�	5�	5�	5�	5�	5����	5�	5�	5�	5�	5�	5s�>A6�6A:�=A:�descrc���tj|jd��}t|d��5}|�|dz�t����ddd��dS#1swxYwYdS)Nr��wb�
)r�r�r[r��write�encoder	)r�r�r�r�s    rV�_set_descriptionzRepo._set_descriptionUs����8�D�L�-�8�8��
�(�D�
!�
!�	4�R��H�H�e�d�l�*�*�6�2�2�3�3�3�	4�	4�	4�	4�	4�	4�	4�	4�	4�	4�	4�	4����	4�	4�	4�	4�	4�	4s�1A)�)A-�0A-zthe project's description)�docc��|jS)zj:return: The working tree directory of our git repository. If this is a bare repository, None is returned.)rZr�s rV�working_tree_dirzRepo.working_tree_dir^s
���%�%rUc��|jp|jS)z�
        :return: The git dir that holds everything except possibly HEAD,
            FETCH_HEAD, ORIG_HEAD, COMMIT_EDITMSG, index, and logs/.)r]r[r�s rVr�zRepo.common_dircs��
��/�4�<�/rUc��|jS)z':return: True if the repository is bare)r�r�s rVrrz	Repo.barejs���z�rU�'IterableList[Head]'c�*�tj|��S)zA list of ``Head`` objects representing the branch heads in
        this repo

        :return: ``git.IterableList(Head, ...)``)r�
list_itemsr�s rV�headsz
Repo.headsos����t�$�$�$rU�'IterableList[Reference]'c�*�tj|��S)zzA list of Reference objects representing tags, heads and remote references.

        :return: IterableList(Reference, ...))rr�r�s rV�
referenceszRepo.referencesw���
�#�D�)�)�)rU�'IndexFile'c� �t|��S)z�:return: IndexFile representing this repository's index.
        :note: This property can be expensive, as the returned ``IndexFile`` will be
         reinitialized. It's recommended to re-use the object.rr�s rV�indexz
Repo.index�s��
����rU�'HEAD'c�"�t|d��S)z;:return: HEAD Object pointing to the current head referencer)rr�s rV�headz	Repo.head�s���D�&�!�!�!rU�'IterableList[Remote]'c�*�tj|��S)zvA list of Remote objects allowing to access and manipulate remotes

        :return: ``git.IterableList(Remote, ...)``)rr�r�s rV�remoteszRepo.remotes�s��
� ��&�&�&rU�origin�name�'Remote'c�r�t||��}|���std|z���|S)zh:return: Remote with the specified name
        :raise ValueError:  if no remote with such a name existszRemote named '%s' didn't exist)rr��
ValueError)r�r��rs   rV�remotezRepo.remote�s=��
�4������x�x�z�z�	F��=��D�E�E�E��rU�'IterableList[Submodule]'c�*�tj|��S)zs
        :return: git.IterableList(Submodule, ...) of direct submodules
            available from the current head)rr�r�s rV�
submoduleszRepo.submodules�r�rU�'Submodule'c�h�	|j|S#t$r}td|z��|�d}~wwxYw)z]:return: Submodule with the given name
        :raise ValueError: If no such submodule existszDidn't find submodule named %rN)r��
IndexErrorr�)r�r��es   rV�	submodulezRepo.submodule�sN��	M��?�4�(�(���	M�	M�	M��=��D�E�E�1�L�����	M���s��
1�,�1�kwargsrc�,�tj|g|�Ri|��S)z�Create a new submodule

        :note: See the documentation of Submodule.add for a description of the
            applicable parameters
        :return: created submodules)r�add�r�r�r�s   rV�create_submodulezRepo.create_submodule�s$���}�T�3�D�3�3�3�F�3�3�3rU�Iterator[Submodule]c�6�t|��j|i|��S)z�An iterator yielding Submodule instances, see Traversable interface
        for a description of args and kwargs

        :return: Iterator)r�traverser�s   rV�iter_submoduleszRepo.iter_submodules�s$��
)�z�$���(�$�9�&�9�9�9rUc�6�t|��j|i|��S)z�Update the submodules, keeping the repository consistent as it will
        take the previous state into consideration. For more information, please
        see the documentation of RootModule.update)r�updater�s   rV�submodule_updatezRepo.submodule_update�s$��'�z�$���&��7��7�7�7rU�'IterableList[TagReference]'c�*�tj|��S)zsA list of ``Tag`` objects that are available in this repo

        :return: ``git.IterableList(TagReference, ...)``)rr�r�s rV�tagsz	Repo.tags�s��
�&�t�,�,�,rUrc�L�|�|��}t||��S)z�:return: TagReference Object, reference pointing to a Commit or Tag
        :param path: path to the tag reference, i.e. 0.1.5 or tags/0.1.5)�_to_full_tag_pathr)r�rc�	full_paths   rV�tagzRepo.tag�s'���*�*�4�0�0�	��D�)�,�,�,rUc���t|��}|�tjdz��r|S|�tjdz��rt
jdz|zStjdz|zS)N�/)rz�
startswithr�_common_path_default�_common_defaultr)rc�path_strs  rVrzRepo._to_full_tag_path�su���t�9�9�����|�@�3�F�G�G�	��O����|�;�c�A�B�B�	F��1�C�7�(�B�B��4�s�:�X�E�ErUrrI�!Union['SymbolicReference', 'str']�force�logmsgrL�'Head'c�2�tj|||||��S)z�Create a new head within the repository.
        For more documentation, please see the Head.create method.

        :return: newly created Head Reference)r�create)r�rcrIr
rs     rV�create_headzRepo.create_head�s���{�4��v�v�u�=�=�=rUr��'Union[str, Head]'c�,�tj|g|�Ri|��S)zfDelete the given heads

        :param kwargs: Additional keyword arguments to be passed to git-branch)r�delete)r�r�r�s   rV�delete_headzRepo.delete_head�s$���{�4�2�%�2�2�2�6�2�2�2rU�ref�Union[str, 'SymbolicReference']�messagec�.�tj|||||fi|��S)z�Create a new tag reference.
        For more documentation, please see the TagReference.create method.

        :return: TagReference object)rr)r�rcrrr
r�s      rV�
create_tagzRepo.create_tag�s%���"�4��s�G�U�M�M�f�M�M�MrUrc�&�tj|g|�R�S)zDelete the given tag references)rr)r�rs  rV�
delete_tagzRepo.delete_tags���"�4�/�$�/�/�/�/rU�urlrc�*�tj|||fi|��S)z�Create a new remote.

        For more information, please see the documentation of the Remote.create
        methods

        :return: Remote reference)rr)r�r�rr�s    rV�
create_remotezRepo.create_remotes ���}�T�4��7�7��7�7�7rUr�c�,�tj||��S)zDelete the given remote.)r�remove)r�r�s  rV�
delete_remotezRepo.delete_remote
s���}�T�6�*�*�*rUr+c	��|�|j}tr|dkrd}|dkrdS|dkr�tj�d��p2tjtj�dd��d��}tjtjtj|d	d
������S|dkr&tjtjd����S|dkr9|j	p|}|st�tjtj|d
����St|td
|������dS)Nr^r`z/etc/gitconfigr_�XDG_CONFIG_HOME�HOME�~z.configr��configz~/.gitconfigrazInvalid configuration level: )
r[rrur�r�r�r�r��
expanduserr]�NotADirectoryErrorr.r�)r�rbr[�config_home�repo_dirs     rV�_get_config_pathzRepo._get_config_paths@���?��l�G��	$�l�h�.�.�#�L��8�#�#�#�#�
�V�
#�
#��*�.�.�):�;�;�o�s�x��
���W]�_b�Hc�Hc�en�?o�?o�K��<���s�x��U�H�/U�/U� V� V�W�W�W�
�X�
%�
%��<���~� >� >�?�?�?�
�\�
)�
)��'�2�7�H��
B�(�(��|�C�H�X�x�$@�$@�A�A�A�
���K�<�K�K�L�L�
�
�
�
�
rU�Optional[Lit_config_levels]rc�.�|�|���S)aw
        :return:
            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 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.)rb)r��r�rbs  rVr�zRepo.config_reader-s��"�"�"��"�=�=�=rUc����|���fd��jD��}n��|���g}t|d����S)Nc���g|]@}tt|�����tt|�������ASrT)r=r+r-)�.0�fr[r�s  ��rV�
<listcomp>z'Repo._config_reader.<locals>.<listcomp>FsU��������)�1�-�-���%�%�d�+<�a�&@�&@�'�J�J���rUT��	read_only�repo)rbr-r)r�rbr[�filess` ` rVr�zRepo._config_reader@sm����
��������*����E�E��*�*�<��A�A�B�E��u��4�@�@�@�@rUrac�L�t|�|��d|���S)a:
        :return:
            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 onlyFr6)rr-r0s  rV�
config_writerzRepo.config_writerOs(���t�4�4�\�B�B�e�Z^�_�_�_�_rU�rev�Union[str, Commit_ish, None]rc�h�|�|jjS|�t|��dz��S)z�The Commit object for the specified revision

        :param rev: revision specifier, see git-rev-parse for viable options.
        :return: ``git.Commit``
        Nz^0)r�rIr$rz�r�r<s  rVrIzRepo.commit^s0���;��9�#�#��~�~�c�#�h�h��o�.�.�.rU�Iterator['Tree']c�0�d�|j|i|��D��S)zg:return: Iterator yielding Tree objects
        :note: Takes all arguments known to iter_commits methodc3�$K�|]}|jV��dSr�)�tree)r3�cs  rV�	<genexpr>z"Repo.iter_trees.<locals>.<genexpr>ks$����C�C�1���C�C�C�C�C�CrU)�iter_commitsr�s   rV�
iter_treeszRepo.iter_treeshs,��D�C� 1�� 1�4� B�6� B� B�C�C�C�CrU�Union[Tree_ish, str, None]�'Tree'c�r�|�|jjjS|�t	|��dz��S)a�The Tree object for the given treeish revision
        Examples::

              repo.tree(repo.heads[0])

        :param rev: is a revision pointing to a Treeish ( being a commit or tree )
        :return: ``git.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�rIrCr$rzr?s  rVrCz	Repo.treems4���;��9�#�(�(��~�~�c�#�h�h��2�3�3�3rU�-Union[str, Commit, 'SymbolicReference', None]�paths�#Union[PathLike, Sequence[PathLike]]�Iterator[Commit]c�F�|�|jj}tj|||fi|��S)a�A list of Commit objects representing the history of a given ref/commit

        :param rev:
            revision specifier, see git-rev-parse for viable options.
            If None, the active branch will be used.

        :param paths:
            is 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 git-rev-list - common ones are
            max_count and skip

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

        :return: ``git.Commit[]``)r�rIr�
iter_items)r�r<rLr�s    rVrFzRepo.iter_commits~s0��0�;��)�"�C�� ��s�E�<�<�V�<�<�<rUr)�List[Union[Commit_ish, None]]c�^�t|��dkrtdt|��z���g}	|jj|i|�����}n%#t
$r}|jdkr�|cYd}~Sd}~wwxYw|D]*}|�|�|�����+|S)aFind the closest common ancestor for the given revision (e.g. Commits, Tags, References, 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 Commit objects. If --all was not specified as kwarg, the list will have at max one Commit,
            or is empty if no common merge base exists.
        :raises ValueError: If not at least two revs are provided
        �z-Please specify at least two revs, got only %i�N)	�lenr�r��
merge_baser�r�status�appendrI)r�r<r��res�lines�err�lines       rVrVzRepo.merge_base�s����s�8�8�a�<�<��L�s�SV�x�x�W�X�X�X�.0��	�'�D�H�'��7��7�7�B�B�D�D�E�E���	�	�	��z�S� � ���J�J�J�J�J�J�����
	�����	*�	*�D��J�J�t�{�{�4�(�(�)�)�)�)��
s�$A�
A=�%
A8�2A=�8A=�ancestor_rev�'Commit'c��	|j�||d���n$#t$r}|jdkrYd}~dS�d}~wwxYwdS)z�Check 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``, ancestor_rev is an ancestor to rev.
        T)�is_ancestorr#NF)r�rVrrW)r�r]r<r[s    rVr`zRepo.is_ancestor�sh��	��H����c�t��D�D�D�D���	�	�	��z�Q����u�u�u�u�u������	�����ts� �
A�<�<�A�sha�object_type�Union[str, None]c�r�	|j�|��}|j�|��}|rT|j|���krdSt
�d|j���|��dSdS#t$rt
�d��YdSwxYw)NTzQCommit hash points to an object of type '%s'. Requested were objects of type '%s'FzCommit hash is invalid.)	r��partial_to_complete_sha_hex�info�typer��log�debugr�r)r�rarb�complete_sha�object_infos     rV�is_valid_objectzRepo.is_valid_object�s���	��8�?�?��D�D�L��(�-�-��5�5�K��
��#�{�'9�'9�';�';�;�;��4��I�I�k�#�(�/�/�1�1�#����
!�5��t���	�	�	��I�I�/�0�0�0��5�5�	���s�AB�3B�$B6�5B6c�v�|jrtj|j|j��}tj|��Sr�)r[r�r��DAEMON_EXPORT_FILEr�)r�r�s  rV�_get_daemon_exportzRepo._get_daemon_export�s3���<�	G��x���d�.E�F�F�H��z�(�#�#�#rU�valuec���|jrtj|j|j��}tj|��}|r|st|��dS|s|rt
j|��dSdSdSr�)r[r�r�rnr�r'ru�unlink)r�rpr��
fileexistss    rV�_set_daemon_exportzRepo._set_daemon_export�s����<�	G��x���d�.E�F�F�H��Z��)�)�
��	 ��	 ��(�O�O�O�O�O��	 �:�	 ��I�h������	 �	 �	 �	 rUz.If True, git-daemon may export this repository�	List[str]c�h�|jrtj|jddd��}tj|��rzt	|d��5}|����t��}ddd��n#1swxYwY|����	��SgS)z�The list of alternates for this repo from which objects can be retrieved

        :return: list of strings being pathnames of alternatesrtrf�
alternatesr�N)
r[r�r�r�r�r�r�r	r�r�)r��alternates_pathr4�altss    rV�_get_alternateszRepo._get_alternates�s����<�	V�!�h�t�|�Y���U�U�O��:�o�&�&�	-��o�t�,�,�
/���v�v�x�x���v�.�.��
/�
/�
/�
/�
/�
/�
/�
/�
/�
/�
/����
/�
/�
/�
/��:�:�<�<�*�*�,�,�,��	s�-B�B�Bryc�l�tj|jddd��}|s,tj|��rt	j|��dSdSt
|d��5}|�d�|���t����ddd��dS#1swxYwYdS)aiSets the alternates

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

        :raise NoSuchPathError:
        :note:
            The method does not check for the existence of the paths in alts
            as the caller is responsible.rtrfrwr�r�N)
r�r�r��isfilerur"r�r�r�r	)r�ryrxr4s    rV�_set_alternateszRepo._set_alternatess����(�4�?�I�v�|�T�T���	8��z�/�*�*�
+��	�/�*�*�*�*�*�
+�
+��o�t�,�,�
8������	�	�$���.�.�v�6�6�7�7�7�
8�
8�
8�
8�
8�
8�
8�
8�
8�
8�
8�
8����
8�
8�
8�
8�
8�
8s�AB)�)B-�0B-zPRetrieve a list of alternates paths or set a list paths to be used as alternatesr��working_tree�untracked_filesr�c��|jrdSgd�}|s|�d��|r$|�dt|��g��|r@t	j|jj��r"t|j	j
dg|�R���rdS|rt|j	j
|���rdS|r't|�||�����rdSdS)z�
        :return:
            ``True``, the repository is considered dirty. By default it will react
            like a git-status 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)�ignore_submodules)r�rX�extendrzr�r|r�rcrUr��diff�_get_untracked_files)r�r�r~rr�rc�default_argss       rV�is_dirtyz
Repo.is_dirtys���:�	��5�@�?�?���	7���� 5�6�6�6��	3�����s�4�y�y� 1�2�2�2��	��z�$�*�/�*�*�
�s�=�4�8�=��3[�l�3[�3[�3[�/\�/\�
��t��	��=�4�8�=�,�/�0�0�
��t��	��4�,�,�T��^�,�T�T�U�U�
��t��urUc�*�|���S)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�s rVrzRepo.untracked_filesAs���(�(�*�*�*rUc�<�|jj|dddd�|��}d}g}|jD]�}|�t��}|�|��s�2|t
|��d��d��}|d|dcxkrdkr`nn]|dd�}|�d	���d
���d���t��}|�	|����t|��|S)NT)�	porcelainr�
as_processz?? r�r����"r#�ascii�unicode_escape�latin1)r�rW�stdoutr�r	rrUr�r�rXr)r�r�r��proc�prefixrr\r�s        rVr�zRepo._get_untracked_filesQs*���t�x����d�W[�f�f�_e�f�f�������K�
	-�
	-�D��;�;�v�&�&�D��?�?�6�*�*�
���C��K�K�M�M�*�1�1�$�7�7�H���{�h�r�l�1�1�1�1�c�1�1�1�1�1�#�A�b�D�>��#�?�?�7�3�3�:�:�;K�L�L�S�S�T\�]�]�d�d�ek�l�l���"�"�8�,�,�,�,�������rUc���	|jj|�}n%#t$r}|jdkrgcYd}~S�d}~wwxYw|�dd���dd���d��S)z�Checks if paths are ignored via .gitignore
        Doing so using the "git check-ignore" method.

        :param paths: List of paths to check whether they are ignored or not
        :return: subset of those paths which are ignored
        r#Nz\\�\r�r\r�)r��check_ignorerrW�replacer�)r�rLr�r[s    rV�ignoredzRepo.ignoredes���		�-���-�u�5�D�D���	�	�	��z�Q����	�	�	�	�	�	������	�����|�|�F�D�)�)�1�1�#�r�:�:�@�@��F�F�Fs��
4�/�4�/�4rc��|jjS)z�The name of the currently active branch.

        :raises	TypeError: If HEAD is detached
        :return: Head to the active branch)r��	referencer�s rV�
active_branchzRepo.active_branchys���y�"�"rU�
str | HEAD�file�Iterator['BlameEntry']c+�(K�|jj|d|fdddd�|��}i}d�|�d��D��}		t|��}n#t$rYdSwxYw|���}|\}	}
}}t|��}
t|��}t|
��}|	|v�rVi}		t|��}n#t$rYdSwxYw|dkr�*|�d	d
��\}}|||<|dkr|}n�Qt
|t|	��tt|d��t|d
�
d���d������t|d��tt|d��t|d�
d���d������t|d�����}|||	<nF		t|��}n#t$rYdSwxYw|�d	d
��\}}|dkr|}n�Et||	t|
|
|z��t|��t|||z����V���V)a�Iterator for blame information for the given file at the given revision.

        Unlike .blame(), this does not return the actual file's contents, only
        a stream of BlameEntry tuples.

        :param rev: revision specifier, see git-rev-parse for viable options.
        :return: lazy iterator of 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_stringc3�K�|]}|�|V��	dSr�rT)r3r\s  rVrEz)Repo.blame_incremental.<locals>.<genexpr>�s'����=�=�4��=�$�=�=�=�=�=�=rU�
Nsboundary� r#sfilenamesauthorsauthor-mail�<�>sauthor-times	committerscommitter-mailscommitter-time��author�
authored_date�	committer�committed_date)r��blamer��next�
StopIterationr�rr rr
�lstripr�rHrJ)r�r<r�r��data�commits�streamr\�
split_line�hexsha�
orig_lineno_b�lineno_b�num_lines_b�lineno�	num_lines�orig_lineno�propsrrp�
orig_filenamerDs                     rV�blame_incrementalzRepo.blame_incremental�s����%�d�h�n�S�$��q��$�af�q�q�jp�q�q��')��=�=�4�:�:�e�#4�#4�=�=�=��@	�
��F�|�|���� �
�
�
����
���������J�;E�8�F�M�8�[���]�]�F��K�(�(�I��m�,�,�K��W�$�$�-/����#�F�|�|����(������������{�*�*�!�!%���D�!�!4�!4�J�C��!&�E�#�J��k�)�)�(-�
���"���v�&�&� �#�E�)�$4�5�5�#�E�.�$9�$@�$@��$F�$F�$M�$M�d�$S�$S�T�T���#&�e�N�&;�"<�"<�#�#�E�,�$7�8�8�#�E�*;�$<�$C�$C�D�$I�$I�$P�$P�QU�$V�$V�W�W���$'�u�->�'?�#@�#@�
�
�
��#$�������#�F�|�|����(�����������!%���D�!�!4�!4�J�C���k�)�)�(-�
��������f�f�y�0�1�1��M�*�*��k�;��#:�;�;�	��
�
�
�w@	s5�A�
A�A�1C�
C�C�H�
H#�"H#�Union[str, HEAD]r��rev_opts�Optional[List[str]]�KList[List[Commit | List[str | bytes] | None]] | Iterator[BlameEntry] | Nonec
�v�|r|j||fi|��S|pg}|jj|g|�d�|�Rddd�|��}i}g}Gd�dtd���}	i}
d}|�|��D�]R}	|����t��}
|j�	|
d��}|d	}d}n#t$r	d
}g}d}YnwxYw|j�|��r�|d�	d��}t|��d
krd|i}
|�dgg����|
d|kr.d|i}
|�|�|��gg����|j�|��}|r�|�d	��}|dkrd|�d��r
|d|
d<��e|�d��rt'|d��|
d<���||kr|d|
d<���|dkrb|�d��r
|d|
d<���|�d��rt'|d��|
d<���||kr|d|
d<��|�d��r
|d|
d<��3|�d��r
|d|
d<��U|d
kr�|
r�|
d}|�|��}|�yt+|t-|��t/j|
d�d|
d����|
dt/j|
d�d|
d����|
d���}|||<||dd	<|dd�@|s|
r|
d	dkr
|
dd�}
|
}n|}|dd�|��d|i}
��T|S)a�The blame information for the given file at the given revision.

        :param rev: revision specifier, see git-rev-parse for viable options.
        :return:
            list: [git.Commit, list: [<line>]]
            A list of lists associating a Commit object with a list of lines that
            changed within the given commit. The Commit objects will be given in order
            of appearance.r�TF)r�r�c�t�eZdZUded<ded<ded<ded<ded<ded<ded	<ded
<ded<ded<d
S)�Repo.blame.<locals>.InfoTDrzra�idr��summaryr��author_emailr��author_dater��committer_email�committer_dateNrOrTrUrV�InfoTDr��sx��������H�H�H��G�G�G��M�M�M��L�L�L��K�K�K����������N�N�N� � � � ������rUr�)�totalr#rr\r�� �r�Nr�z-mailr�z-timer�r�r�r�r�r�r��	)r�r�r�r@r�r�r�r	�
re_whitespacer��UnicodeDecodeError�re_hexsha_onlyr|rUrXr��re_author_committer_start�group�endswithr�rrr r�_from_string)r�r<r�r�r�r�r�r��blamesr�rf�keepends�
line_bytes�line_str�parts�	firstpart�	is_binary�digits�m�rolerarDr\s                       rVr�z
Repo.blame�s��� �	?�)�4�)�#�t�>�>�v�>�>�>��>�r��$�d�h�n�S�j�8�j�T�j�4�j�j�4�Z_�j�j�ci�j�j��%'��@B��
	 �
	 �
	 �
	 �
	 �Y�e�
	 �
	 �
	 �
	 ������/�/�(�3�3�b	/�b	/�J�

"�%�,�,�.�.�5�5�f�=�=���*�0�0��1�=�=��!�!�H�	�!�	�	��&�
!�
!�
!��	��� �	�	�	�
!�����"�)�)�)�4�4�Q
/�
�r�����-�-���v�;�;�!�#�#� �)�,�D��M�M�4��*�-�-�-�-��$�Z�9�,�,� �)�,�D��M�M�7�;�;�y�#9�#9�2�">�?�?�?���2�9�9�)�D�D���B/��7�7�1�:�:�D��x�'�'�$�-�-�g�6�6�7�38��9�D��0�0�&�/�/��8�8�7�25�e�B�i�.�.�D��/�/�!�Y�.�.�-2�2�Y�D��N����,�,�$�-�-�g�6�6�:�6;�B�i�D�!2�3�3�&�/�/��8�8�:�58��r��^�^�D�!1�2�2�!�Y�.�.�05�b�	�D��-��!�+�+�J�7�7�#/�+0��9��Z�(�(�"�-�-�i�8�8�!/�*/��)��Y���"�b����/�"&�t�*�C� '���C� 0� 0�A� �y�$*�$(�$.�s�O�O�+0�+=��h��>h�>h�RV�We�Rf�>h�>h�+i�+i�26�}�2E�.3�.@�D��DU�Aq�Aq�X\�]n�Xo�Aq�Aq�.r�.r�37�8H�3I�
%"�%"�%"��01����,-�F�2�J�q�M� &�b�z�!�}�8�'0�!6�'/�%@�H�Q�K�4�4G�4G�3;�A�B�B�<��+3�D�D�+5�D�
!'�r�
�1�
� 4� 4�T� :� :� :�$(�#�;�D��
�
s�),B;�;C�
C�Union[PathLike, None]�mkdir�Type[GitCmdObjectDB]c���|rt||��}|r+|r)tj|��stj|d��|�|��}|jdi|��|||���S)a]Initialize a git repository at the given path if specified

        :param path:
            is 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 exists. 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 git-init command

        :return: ``git.Repo`` (the newly created repo)i��rdrT)r!r�r�ru�makedirsr��init)�clsrcr�rdrhr�r�s       rVr�z	Repo.initfs���F�	2��t�[�1�1�D��	%�T�	%�#�*�T�"2�"2�	%��K��e�$�$�$��'�'��-�-�������6�����s�4�d�#�#�#�#rUr��'Git'�odb_default_type�progress�PUnion['RemoteProgress', 'UpdateProgress', Callable[..., 'RemoteProgress'], None]�
multi_options�allow_unsafe_protocols�allow_unsafe_optionsc		���|	�d|��}
t|t��st|��}tj��rd|	vrtj|��n|}|	�d��}|rtj|��|	d<d}
|r'tjd�	|����}
|s!tj
t|����|s:tjt|	�
����|j���|s|rtj||j���|j|
dtjt|����|fddddd�t!|	||����}|r9t#|dt%|�����t(d	�
��nd|���\}}t-|dd��}t/|��}t0�d
||��t)||���t5j|��s#|j�t5j	|j|��n|}|||
���}|jjdi|�����|j rb|j dj!5}|�"dtj|j dj#����ddd��n#1swxYwY|S)Nrdrr�separate_git_dirr�)�options�unsafe_optionsr�T)�with_extended_outputr��v�universal_newlinesF)�decode_streamsr�r\zCmd(%s)'s unused stdout: %s)�stderrr�rrrT)$�popryrzrrx�
polish_urlr��shlexr�r��check_unsafe_protocols�check_unsafe_options�list�keys�unsafe_git_clone_options�clonerrr�new_message_handlerr�communicate�getattrr"rhrir��isabs�_working_dirr��update_environment�environmentr�r;�	set_valuer)r�r�rrcr�r�r�r�r�r�rd�
clone_path�sep_dir�multir�r�r��cmdliner8�writers                    rV�_clonezRepo._clone�s[���z�z�&�"2�3�3���$��$�$�	��t�9�9�D�.1�]�_�_�[��6�AQ�AQ�S�^�D�)�)�)�W[�
��*�*�/�0�0���	A�),���)@�)@�F�%�&����	9��K����� 7� 7�8�8�E�%�	1��&�s�3�x�x�0�0�0�#�	o��$�T�&�+�+�-�-�-@�-@�QT�Qm�n�n�n�n�#�	i�
�	i��$�]�3�Kg�h�h�h�h��s�y����N�3�s�8�8�$�$��	

�
"&���#�

�

��6�3��1�1�

�

���	2�!���$�X�.�.�B�B�D�D� �$�
�
�
�
�
� $�/�/�1�1��V�V��d�F�B�/�/�G�0��9�9�G��I�I�3�W�f�E�E�E��T�&�1�1�1�1��y����	^�7:�7G�7S�3�8�C�,�d�3�3�3�Y]�D��s�4�d�#�#�#��	$���#�8�8�c�o�o�&7�&7�8�8�8��<�	M���a��.�
M�&�� � ����t�|�A��7J�(K�(K�L�L�L�
M�
M�
M�
M�
M�
M�
M�
M�
M�
M�
M����
M�
M�
M�
M��s�#9K(�(K,�/K,�Optional[Callable]c�f�|j|j|j|t|j��||f||d�|��S)a�Create a clone from this repository.

        :param path: is the full path of the new repo (traditionally ends with ./<name>.git).
        :param progress: See 'git.remote.Remote.push'.
        :param multi_options: A list of Clone 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 Repo instance
            * All remaining keyword arguments are given to the git-clone command

        :return: ``git.Repo`` (the newly cloned repo)�r�r�)rr�r�rgr�)r�rcr�r�r�r�r�s       rVrz
Repo.clone�sT��2�t�{��H��O�����N�N���

�$:�!5�

�

��

�

�
	
rU�to_path�env�Optional[Mapping[str, str]]c��|�tj����}	|�
|	jdi|��|j|	||t
||f||d�|��S)aCreate a clone from the given URL

        :param url: valid git url, see http://www.kernel.org/pub/software/scm/git/docs/git-clone.html#URLS
        :param to_path: Path to which the repository should be cloned to
        :param progress: See '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 `os.environ`, value from `os.environ` will be used.
            If you want to unset some variable, consider providing empty string
            as its value.
        :param multi_options: See ``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 ``clone`` method
        :return: Repo instance pointing to the cloned directoryNrrT)r�rurwrrr
)
r�rrr�rr�r�r�r�r�s
          rV�
clone_fromzRepo.clone_froms��8�'�'��	���4�4���?�"�C�"�)�)�S�)�)�)��s�z�������

�$:�!5�

�

��

�

�
	
rU�ostream�Union[TextIO, BinaryIO]�treeishr�c�d�|�|jj}|r	d|vr||d<||d<|�dg��}ttt
tt
tt
dff|��}t|ttf��s|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: is the treeish name/id, defaults to active branch
        :param prefix: is the optional prefix to prepend to each filename in the archive
        :param kwargs: Additional arguments passed to git-archive

            * 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 GitCommandError: in case something went wrong
        :return: selfNr��
output_streamrc.r�)
r�rIr�r=r;r*r4r9ry�tupler�r��archive)r�rrr�r�rcs      rVrzRepo.archive;s���*�?��i�&�G��	&�h�f�,�,�%�F�8��")�����z�z�&�"�%�%���E�(�D��N�E�(�C�-�4H�H�I�4�P�P���$���
�.�.�	��6�D������w�8��8�8�8��8�8�8��rUc�~�|jrdS|jr,tjtj|jd����SdS)a
        :return: True if our git_dir is not at the root of our working_tree_dir, but a .git file with a
            platform agnositic symbolic link. Our git_dir will be wherever the .git file points to
        :note: bare repositories will always return False here
        Frq)rrr�r�r|r�r�s rV�has_separate_working_treezRepo.has_separate_working_tree]sB���9�	��5�� �	��:�c�h�t�'<�f�E�E�F�F�F��5rUc�F�|j}d|j�d|j�d|j�d�S)N�<�.r��>)�	__class__rQrPr[)r��clazzs  rV�__repr__z
Repo.__repr__ls-������$�/�/�/���������N�NrU�
Commit | Nonec�6�|jrtj|jd��}tj|��sdSt	|d��5}|������}ddd��n#1swxYwY|�|��S)z�
        :return: The commit which is currently being replayed while rebasing.

        None if we are not currently rebasing.
        �REBASE_HEADN�rt)r[r�r�r|r��readliner�rI)r��rebase_head_filer4�contents    rV�currently_rebasing_onzRepo.currently_rebasing_onps����<�	E�"�x���m�D�D���z�*�+�+�	��4�
�"�D�
)�
)�	+�Q��j�j�l�l�(�(�*�*�G�	+�	+�	+�	+�	+�	+�	+�	+�	+�	+�	+����	+�	+�	+�	+��{�{�7�#�#�#s�'A;�;A?�A?)
rcrYrdrerfrgrhrgrirj)rir�)r�r/rirj)rirj)r�r�rirg)rir�)rirz)r�rzrirj)rirY)rir*)rirg)rir�)rir�)rir�)rir�)rir�)r�)r�rzrir�)rir�)r�rzrir�)r�r/r�r/rir)r�r/r�r/rir�)rir�)rcr*rir)rcr*rirz)rFN)
rcr*rIrr
rgrrLrir)r�rr�r/rirj)rNF)rcr*rrrrLr
rgr�r/rir)rrrirj)r�rzrrzr�r/rir)r�r�rirzr�)rbr+r[rYrirz)rbr.rir)NN)rbr.r[rYrir)ra)rbr+rir)r<r=rir)r�r/r�r/rir@)r<rHrirI)Nr\)r<rKrLrMr�r/rirN)r<r)r�r/rirQ)r]r^r<r^rirg)rarzrbrcrirg)rpr�rirj)riru)ryrurirj)TTFTN)r�rgr~rgrrgr�rgrcrYrirg)r�r/r�r/riru)rLr*riru)rir)r<r�r�rzr�r/rir�)FN)r<r�r�rzr�rgr�r�r�r/rir�)rcr�r�rgrdr�rhrgr�r/rir�)NNFF)r�r�rr*rcr*r�r�r�r�r�r�r�rgr�rgr�r/rir�)rcr*r�rr�r�r�rgr�rgr�r/rir�)NNNFF)rr*rr*r�rrrr�r�r�rgr�rgr�r/rir�)
rrrrLr�rLr�r/rirF)rir))_rPrQrR�__doc__rnr=r�rSrZr]r{�compiler�r��re_hexsha_shortenedr}r��re_tab_full_linerrbrr�r
r�r�r�r�r�r�r�r�r�r��propertyr�r�r�rrr�r��refs�branchesr�r�r�r�r�r�r�r�r�rr�staticmethodrrrrrr r#r-r�r�r;rIrGrCrFrVr`rlrort�
daemon_exportrzr}rwr�rr�r�r�r�r��classmethodr�rrrrr!r$r(r0rTrUrVrFrFlsq�������H�H�0��
�$�u�d�
�
�C�����,0��0�0�0�0������K������B�J�v�&�&�M��R�Z� 3�4�4�N�$�"�*�%:�;�;�����T�U�U�J� *��
�+A� B� B��!�r�z�+�.�.��
 �
 �
 ��&P�L�O�O�O�O� ��$(�$2�*/� �H&�H&�H&�H&�H&�T������������
�
�
�
�����
$�$�$�$�"�"�"�"�5�5�5�5�
4�4�4�4�
�(�+�-=�C^�_�_�_�K���
�&�&�&��X�&��0�0�0��X�0������X���%�%�%��X�%��*�*�*��X�*��D��H�
�����X���"�"�"��X�"��'�'�'��X�'�������*�*�*��X�*�M�M�M�M�4�4�4�4�:�:�:�:�8�8�8�8��-�-�-��X�-�-�-�-�-��F�F�F��\�F�5;�� $�>�>�>�>�>�3�3�3�3�06�!%��N�N�N�N�N�0�0�0�0�8�8�8�8�+�+�+�+������<59�>�>�>�>�>�*59�&*�
A�
A�
A�
A�
A�
`�
`�
`�
`�
`�/�/�/�/�/�D�D�D�D�
4�4�4�4�4�&>B�57�=�=�=�=�=�:����>
�
�
�
������($�$�$�$�
 � � � ��H���<����M�
	������8�8�8�8�&����^����J��!� %��#'�
&�&�&�&�&�P�
+�
+�
+��X�
+�����(G�G�G�G�(�#�#�#��X�#�S�S�S�S�r"�(,�M�M�M�M�M�^�'+��%3� �*$�*$�*$�*$��[�*$�X�fj�-1�',�%*�U�U�U�U��[�U�t(,�-1�',�%*�
#
�#
�#
�#
�#
�J�
(,�+/�-1�',�%*�(
�(
�(
�(
��[�(
�Z"&� $�	 � � � � �D�����I�O�O�O�O�$�$�$�$�$�$rUrF)e�
__future__r�loggingrur{r�r~�pathlibr�gitdb.db.looser�	gitdb.excr�git.cmdrr�
git.compatr	r
r�
git.configr�git.dbr
�git.excrrr�	git.indexr�git.objectsrrr�git.refsrrrr�
git.remoterrr�git.utilrrrr r!r"�os.pathrcr��funr$r%r&r'r(r�r��	git.typesr)r*r+r,r-r.�typingr/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rA�git.refs.symbolicrBrC�git.objects.submodule.baserDrE�	getLoggerrPrh�__all__rHr�rFrTrUrV�<module>rRsQ��#�"�"�"�"�"�����	�	�	�	�	�	�	�	���������������(�(�(�(�(�(�������.�.�.�.�.�.�.�.�����������
'�&�&�&�&�&�!�!�!�!�!�!�����������
 ������5�5�5�5�5�5�5�5�5�5�8�8�8�8�8�8�8�8�8�8�8�8�A�A�A�A�A�A�A�A�A�A�������������������������������������
�	�	�	���������������������������������������������������������&2�1�1�1�1�1�1�1��*�%�%�%�%�%�%�3�3�3�3�3�3� � � � � � �9�9�9�9�9�9�)�)�)�)�)�)��g���!�!��
�����������P$�P$�P$�P$�P$�6�P$�P$�P$�P$�P$rU