ok

Mini Shell

Direktori : /opt/cloudlinux/venv/lib/python3.11/site-packages/git/refs/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib/python3.11/site-packages/git/refs/__pycache__/symbolic.cpython-311.pyc

�

�܋fu��b�ddlmZddlZddlmZddlmZddlmZddl	m
Z
mZmZm
Z
mZmZddlmZmZdd	lmZdd
lmZmZmZmZmZmZmZmZmZddlmZmZer$ddl m!Z!dd
l"m#Z#m$Z$m%Z%m&Z&ddlm'Z'ddl(m)Z)ddlm*Z*edd���Z+dgZ,dddeedfdefd�Z-Gd�de.��Z/dS)�)�PathLikeN)�defenc)�Object)�Commit)�	join_path�join_path_native�to_native_path_linux�assure_directory_exists�
hex_to_bin�LockedFD)�	BadObject�BadName�)�RefLog)	�Any�Iterator�List�Tuple�Type�TypeVar�Union�
TYPE_CHECKING�cast)�
Commit_ishr)�Repo��Head�TagReference�RemoteReference�	Reference)�RefLogEntry)�GitConfigParser)�Actor�T_References�SymbolicReference)�bound�repor�path�returnc�,�|�}|dvr|jS|jS)z0Find the git dir that's appropriate for the path)�HEAD�	ORIG_HEAD�
FETCH_HEAD�index�logs)�git_dir�
common_dir)r'r(�names   �b/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/git/refs/symbolic.py�_git_dirr42s%���9�D��C�C�C��|���?��c��eZdZUdZdZdZdZdZdZdZ	dJdd	d
e
defd�Zd
e
fd�Zd
e
fd�Zded
efd�Zded
efd�Zd
efd�Zed
e
fd���Zed
e
fd���Zedd	d
e
fd���Zedd	d
eee
e
ffd���Zedd	dee
dfd
e
fd���Zedd	dee
dfd
eee
dfede
fffd���Zedd	dee
dfd
eee
dfede
fffd���Z d
e!fd�Z"dKd�Z#	dLd ee$de
fd!ee
dfd
dfd"�Z%	dLd#ee!de
fd!ee
dfd
dfd$�Z&ee#e%d%�&��Z'ee"e&d'�&��ZdMd(�Z(	dLd)ee!de
fd!ee
dfd
dfd*�Z)ed+e*d,<ee(e)d-�&��Z+e+Z,d
efd.�Z-ed
efd/���Z.dNd1�Z/	dLd2e0d3ee
dfd4ee0dfd
d5fd6�Z1d7ed
d5fd8�Z2ed
ee
dfd
e
fd9���Z3edd	d
e
d
dfd:���Z4e	dLd;e5e6dd	d
e
d<ed,ede
fd=ed!ee
dfd
e6fd>���Z7e			dOd;e5e6dd	d
e
d,ede
fd!ee
dfd=ed@e8d
e6fdA���Z9dJdBe
d=ed
dfdC�Z:e	dLd;e5e6dd	dDee
dfd
ee6fdE���Z;e	dLd;e5e6dd	dDee
dfdFe8d@e8d
ee6fdG���Z<ed;e5e6dd	d
e
d
e6fdH���Z=d
efdI�Z>dS)Pr%z�Represents a special case of a reference such that this reference is symbolic.
    It does not point to a specific commit, but to another Head, which itself
    specifies a commit.

    A typical example for a symbolic reference is HEAD.�r'r(FT�zrefs/remotesr2r'rr(�
check_pathc�"�||_||_dS�Nr7)�selfr'r(r9s    r3�__init__zSymbolicReference.__init__Is����	���	�	�	r5r)c�*�t|j��Sr;��strr(�r<s r3�__str__zSymbolicReference.__str__Ms���4�9�~�~�r5c�2�d|jj�d|j�d�S)Nz<git.z "z">)�	__class__�__name__r(rAs r3�__repr__zSymbolicReference.__repr__Ps ���"&�.�"9�"9�"9�4�9�9�9�E�Er5�otherc�p�t|d��r%tt|��}|j|jkSdS)Nr(F)�hasattrrr%r(�r<rGs  r3�__eq__zSymbolicReference.__eq__Ss8���5�&�!�!�	+��*�E�2�2�E��9��
�*�*��ur5c��||kSr;�rJs  r3�__ne__zSymbolicReference.__ne__Ys���E�M�"�"r5c�*�t|j��Sr;)�hashr(rAs r3�__hash__zSymbolicReference.__hash__\s���D�I���r5c�*�t|j��S)zy
        :return:
            In case of symbolic references, the shortest assumable name
            is the path itself.r?rAs r3r2zSymbolicReference.name_s���4�9�~�~�r5c�\�tt|j|j��|j��Sr;)rr4r'r(rAs r3�abspathzSymbolicReference.abspathgs"������D�I� >� >��	�J�J�Jr5c�L�tj�|jd��S)N�packed-refs)�osr(�joinr1)�clsr's  r3�_get_packed_refs_pathz'SymbolicReference._get_packed_refs_pathks���w�|�|�D�O�]�;�;�;r5c#�K�	t|�|��dd���5}|D]�}|���}|s�|�d��r,|�d��rd|vrt	d|z����Z|dd	kr�gttttft|�	d
d������V���	ddd��dS#1swxYwYdS#t$rYdSwxYw)
z�Returns an iterator yielding pairs of sha1/path pairs (as strings) for the corresponding refs.
        :note: The packed refs file will be kept open as long as we iterate�rt�UTF-8��encoding�#z# pack-refs with:�peeledz-PackingType of packed-Refs not understood: %rr�^� rN)�openrZ�strip�
startswith�	TypeErrorrrr@�tuple�split�OSError)rYr'�fp�lines    r3�_iter_packed_refsz#SymbolicReference._iter_packed_refsos�����	��c�/�/��5�5�t�g�N�N�N�
K�RT��K�K�D��:�:�<�<�D��!� ����s�+�+�!� �?�?�+>�?�?�d�H�TX�DX�DX�"+�,[�^b�,b�"c�"c�c� �
�A�w�#�~�~� ��u�S�#�X���d�j�j��a�6H�6H�0I�0I�J�J�J�J�J�J�1K�
K�
K�
K�
K�
K�
K�
K�
K�
K�
K�
K�
K����
K�
K�
K�
K�
K�
K��6�	�	�	��4�4�	���s5�%C9�B5C,�C9�,C0�0C9�3C0�4C9�9
D�D�ref_pathNc�@�	|�||��\}}|�|S�)z�
        :return: hexsha stored in the reference at the given ref_path, recursively dereferencing all
            intermediate references as required
        :param repo: the repository containing the reference at ref_path)�
_get_ref_info)rYr'rn�hexshas    r3�dereference_recursivez'SymbolicReference.dereference_recursive�s1��	�"�0�0��x�@�@��F�H��!��
�	r5c��d}t||��}	ttj�|t|����dd���5}|������}ddd��n#1swxYwY|���}t|��dksJ�n6#t$r)|�|��D]\}}||kr�||f}YnwxYw|�td|z���|ddkr
d|dfS|j
�|d��r
|ddfStd	|z���)
��Return: (str(sha), str(target_ref_path)) if available, the sha the file at
        rela_path points to, or None. target_ref_path is the reference we
        point to, or NoneNr\r]r^rzReference at %r does not existzref:rz-Failed to parse reference information from %r)r4rdrWr(rXr@�read�rstripri�lenrjrm�
ValueError�re_hexsha_only�match)	rYr'rn�tokens�repodirrk�value�shar(s	         r3�_get_ref_info_helperz&SymbolicReference._get_ref_info_helper�s���;?���4��*�*��	��b�g�l�l�7�C��M�M�:�:�D�7�S�S�S�
+�WY����	�	�(�(�*�*��
+�
+�
+�
+�
+�
+�
+�
+�
+�
+�
+����
+�
+�
+�
+��[�[�]�]�F��v�;�;�!�#�#�#�#�#���		�		�		�!�2�2�4�8�8�
�
�	��T��8�#�#���d������		�����>��=��H�I�I�I��!�9�����&��)�$�$���$�$�V�A�Y�/�/�	%��1�I�t�$�$��H�8�S�T�T�Ts5�=B9�'B�8B9�B�B9�B�,B9�90C,�+C,c�.�|�||��S)rt)r)rYr'rns   r3rpzSymbolicReference._get_ref_info�s��
�'�'��h�7�7�7r5c	��tj|jt|�|j|j������S)z�
        :return:
            The object our ref currently refers to. Refs can be cached, they will
            always point to the actual object as it gets re-created on each query)r�new_from_shar'rrrr(rAs r3�_get_objectzSymbolicReference._get_object�s9���"�4�9�j��9S�9S�TX�T]�_c�_h�9i�9i�.j�.j�k�k�kr5rc��|���}|jdkr|j}|jtjkrt	d|z���|S)z�
        :return:
            Commit object we point to, works for detached and non-detached
            SymbolicReferences. The symbolic reference will be dereferenced recursively.�tagz<Symbolic Reference pointed to object %r, commit was required)r��type�objectrrg)r<�objs  r3�_get_commitzSymbolicReference._get_commit�sT��
��� � ���8�u����*�C��8�v�{�"�"��Z�]`�`�a�a�a��
r5�commit�logmsgc���d}t|t��r|jtjk}n�t|t��r|jjtjk}n[	|j�|��jtjk}n,#ttf$r}td|z��|�d}~wwxYw|rtd|z���|�||��|S)z�As set_object, but restricts the type of object to be a Commit

        :raise ValueError: If commit is not a Commit object or doesn't point to
            a commit
        :return: selfFzInvalid object: %sNzNeed commit, got %r)�
isinstancerr�rr%r�r'�	rev_parser
rrx�
set_object)r<r�r��invalid_type�es     r3�
set_commitzSymbolicReference.set_commit�s������f�f�%�%�	G�!�;�&�+�5�L�L�
�� 1�
2�
2�	G�!�=�-���<�L�L�
G�#�y�2�2�6�:�:�?�6�;�N�����w�'�
G�
G�
G� �!5��!>�?�?�Q�F�����
G����
�	=��2�V�;�<�<�<�	
�����'�'�'��s�-B
�
B6�B1�1B6r�c���t|t��r|j}d}	|j}n#t$rYnwxYw|r|�||��S|����||��S)a8Set the object we point to, possibly dereference our symbolic reference first.
        If the reference does not exist, it will be created

        :param object: a refspec, a SymbolicReference or an Object instance. SymbolicReferences
            will be dereferenced beforehand to obtain the object they point to
        :param logmsg: If not None, the message will be used in the reflog entry to be
            written. Otherwise the reflog is not altered
        :note: plain SymbolicReferences may not actually point to objects by convention
        :return: selfT)r�r%r��is_detachedrx�
set_reference�_get_referencer�)r<r�r�r�s    r3r�zSymbolicReference.set_object
s����f�/�0�0�	#��]�F���	��*�K�K���	�	�	��D�	�����	6��%�%�f�f�5�5�5��"�"�$�$�/�/���?�?�?s�(�
5�5zQuery or set commits directly)�docz-Return the object our ref currently refers toc��|�|j|j��\}}|�t|�d|�����|�|j|��S)z�:return: Reference Object we point to
        :raise TypeError: If this symbolic reference is detached, hence it doesn't point
            to a reference, but to a commitNz2 is a detached symbolic reference as it points to )rpr'r(rg�	from_path)r<r~�target_ref_paths   r3r�z SymbolicReference._get_reference/s\�� $�1�1�$�)�T�Y�G�G���_��"��X\�X\�X\�^a�^a�b�c�c�c��~�~�d�i��9�9�9r5�refc���d}d}t|t��rd|jz}n�t|t��r
|}|j}nyt|t
��rR	|j�|dz��}|j}n>#ttf$r}td|z��|�d}~wwxYwtd|z���|�.|jr'|jtjkrtd|z���d}|�*	|jj}n#t$rtj}YnwxYw|j}t'|d�	��t)|��}|�dd�
��}	d}
	|	�|�d��dz��|���d}
|
s|���n#|
s|���wwxYw|�|�||��|S)
a�Set ourselves to the given ref. It will stay a symbol if the ref is a Reference.
        Otherwise an Object, given as Object instance or refspec, is assumed and if valid,
        will be set which effectively detaches the reference if it was a purely
        symbolic one.

        :param ref: SymbolicReference instance, Object instance or refspec string
            Only if the ref is a SymbolicRef instance, we will point to it. Everything
            else is dereferenced to obtain the actual object.
        :param logmsg: If set to a string, the message will be used in the reflog.
            Otherwise, a reflog entry is not written for the changed reference.
            The previous commit of the entry will be the commit we point to now.

            See also: log_append()

        :return: self
        :note: This symbolic reference will not be dereferenced. For that, see
            ``set_object(...)``Nzref: %sz^{}z Could not extract object from %szUnrecognized Value: %rzRequire commit, got %rr5T)�is_file)�write�streamzutf-8�
)r�r%r(rrqr@r'r�r
rrx�_points_to_commits_onlyr�rrgr��binsha�NULL_BIN_SHArTr
rrdr��encode�rollback�
log_append)r<r�r��write_valuer�r��	oldbinsha�fpath�lfd�fd�oks           r3r�zSymbolicReference.set_reference8s)��,�����c�,�-�-�
	=�#�c�h�.�K�K�
��V�
$�
$�	=��C��*�K�K�
��S�
!�
!�	=�
R��i�)�)�#��+�6�6��!�j�����w�'�
R�
R�
R� �!C�c�!I�J�J�PQ�Q�����
R�����5��;�<�<�<��?�t�;�?���F�K�@W�@W��4�s�:�;�;�;��	���
0� �K�.�	�	���
0�
0�
0�"�/�	�	�	�
0����
�����t�4�4�4�4��u�o�o��
�X�X�D��X�
.�
.��
��	��H�H�[�'�'��0�0�5�8�9�9�9��J�J�L�L�L��B��
����������
��������
�������O�O�I�v�.�.�.��s7�$A?�?B(�B#�#B(�2C?�?D�D�AF4�4G
r�	referencez!Returns the Reference we point toc�F�	|jdS#ttf$rYdSwxYw)z�
        :return:
            True if the reference is valid, hence it can be read and points to
            a valid object or reference.TF)r�rjrxrAs r3�is_validzSymbolicReference.is_valid�s>��
	��K�K��4����$�	�	�	��5�5�	���s�� � c�8�	|jdS#t$rYdSwxYw)z�
        :return:
            True if we are a detached reference, hence we point to a specific commit
            instead to another referenceFT)r�rgrAs r3r�zSymbolicReference.is_detached�s5��	��H�H��5���	�	�	��4�4�	���s��
�rc�N�tjtj|����S)a.
        :return: RefLog for this reference. Its last entry reflects the latest change
            applied to this reference

        .. note:: As the log is parsed every time, its recommended to cache it for use
            instead of calling this method repeatedly. It should be considered read-only.)r�	from_filer(rAs r3�logzSymbolicReference.log�s������D� 1� 1�2�2�2r5r��message�	newbinshar!c���	|jj}n)#t$r|j���}YnwxYw|�|jj}|�d}t
j|t
j|��|||��S)aBAppend a logentry to the logfile of this ref

        :param oldbinsha: binary sha this ref used to point to
        :param message: A message describing the change
        :param newbinsha: The sha the ref points to now. If None, our current commit sha
            will be used
        :return: added RefLogEntry instanceNr8)	r��	committerrxr'�
config_readerr�r�append_entryr()r<r�r�r��committer_or_readers     r3r�zSymbolicReference.log_append�s��� 	<�EI�[�EZ�����	<�	<�	<�"&�)�"9�"9�";�";����	<��������*�I��?��G��"�#6���D�8I�8I�9�V_�ah�i�i�is��#5�5r.c�P�tjtj|��|��S)aW:return: RefLogEntry at the given index
        :param index: python list compatible positive or negative index

        .. note:: This method must read part of the reflog during execution, hence
            it should be used sparringly, or only if you need just one index.
            In that case, it will be faster than the ``log()`` method)r�entry_atr()r<r.s  r3�	log_entryzSymbolicReference.log_entry�s ����v�{�4�0�0�%�8�8�8r5c��t|t��r|j}|}|js|St	|���|jdz��s|j�d|��}|S)z�
        :return: string with a full repository-relative path which can be used to initialize
            a Reference instance, for instance by using ``Reference.from_path``�/)r�r%r(�_common_path_defaultr@rf)rYr(�
full_ref_paths   r3�to_full_pathzSymbolicReference.to_full_path�st��
�d�-�.�.�	��9�D��
��'�	!� � ��4�y�y�#�#�C�$<�s�$B�C�C�	G�'*�'?�'?�'?���F�M��r5c��|�|��}tj�|j|��}tj�|��rtj|���n;|�|��}	t|d��5}g}d}d}	|D]�}
|
�	t��}|�d��\}}}
|
���}
|�
d��s||
kr1|	r|	r-|�
d��s|�|��d}	��d}d}	��	ddd��n#1swxYwY|rGt|d��5}|�d	�|D����ddd��n#1swxYwYn#t $rYnwxYwt#j|||����}tj�|��rtj|��dSdS)
aRDelete the reference at the given path

        :param repo:
            Repository to delete the reference from

        :param path:
            Short or full path pointing to the reference, i.e. refs/myreference
            or just "myreference", hence 'refs/' is implied.
            Alternatively the symbolic reference to be deleted�rbFrcr`rbTN�wbc3�JK�|]}|�t��V��dSr;)r�r)�.0rls  r3�	<genexpr>z+SymbolicReference.delete.<locals>.<genexpr>s.����%P�%P�d�d�k�k�&�&9�&9�%P�%P�%P�%P�%P�%Pr5)r�rWr(rXr1�exists�removerZrd�decoder�	partitionrerf�append�
writelinesrjr�isfile)rYr'r(r��abs_path�pack_file_path�reader�	new_lines�made_change�dropped_last_line�
line_bytesrl�_�line_refr��reflog_paths                r3�deletezSymbolicReference.delete�s����(�(��.�.�
��7�<�<����?�?��
�7�>�>�(�#�#�&	��I�h�����!�6�6�t�<�<�N�!
��.�$�/�/�1�6� "�I�"'�K�(-�%�&,�1�1�
�)�0�0��8�8��)-����)<�)<���1�h�#+�>�>�#3�#3��
!�O�O�C�0�0�%�M�X�4M�4M� 1�5N�5F�5N�OS���_b�Oc�Oc�5N�&�,�,�T�2�2�2�05�-�$�'+��,0�)�)�%1�	1�1�1�1�1�1�1�1�1�1�1����1�1�1�1�2�Q��n�d�3�3�Q�r��
�
�%P�%P�i�%P�%P�%P�P�P�P�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q����Q�Q�Q�Q����
�
�
���
�����k�#�#�d�M�":�":�;�;��
�7�>�>�+�&�&�	#��I�k�"�"�"�"�"�	#�	#s[�F�B#E�:F�E
�
F�
E
�F�# F�F�F�F�F�F�
F(�'F(rY�resolve�forcec���t||��}|�|��}tj�||��}	|}
|r"|�t
|����}
|s�tj�|	��r�t
|
��}t|
t��rt
|
j��}|sd|z}t|	d��5}|����t�����}
ddd��n#1swxYwY|
|krtd|�d|
�d|�����|||��}|�|
|��|S)a*internal method used to create a new symbolic reference.
        If resolve is False, the reference will be taken as is, creating
        a proper symbolic reference. Otherwise it will be resolved to the
        corresponding object and a detached symbolic reference will be created
        insteadzref: r�Nz
Reference at z! does already exist, pointing to z, requested was )r4r�rWr(rXr�r@r�r�r%rdrur�rrerjr�)rYr'r(r�r�r�r�r0r��abs_ref_path�target�target_datar��
existing_datar�s               r3�_createzSymbolicReference._creates����4��&�&���(�(��.�.�
��w�|�|�G�]�;�;�����	4��^�^�C�	�N�N�3�3�F��	������5�5�	��f�+�+�K��&�"3�4�4�
/�!�&�+�.�.���
4�%��3���l�D�)�)�
A�R� "���	�	� 0� 0�� 8� 8� >� >� @� @�
�
A�
A�
A�
A�
A�
A�
A�
A�
A�
A�
A����
A�
A�
A�
A���+�+��g�$�}�}�m�m�m�[�[�B�����c�$�
�&�&�����&�&�)�)�)��
s�?D'�'D+�.D+r+�kwargsc�@�|�|||j|||��S)aCreate a new symbolic reference, hence a reference pointing , to another reference.

        :param repo:
            Repository to create the reference in

        :param path:
            full path at which the new symbolic reference is supposed to be
            created at, i.e. "NEW_HEAD" or "symrefs/my_new_symref"

        :param reference:
            The reference to which the new symbolic reference should point to.
            If it is a commit'ish, the symbolic ref will be detached.

        :param force:
            if True, force creation even if a symbolic reference with that name already exists.
            Raise OSError otherwise

        :param logmsg:
            If not None, the message to append to the reflog. Otherwise no reflog
            entry is written.

        :return: Newly created symbolic Reference

        :raise OSError:
            If a (Symbolic)Reference with the same name but different contents
            already exists.

        :note: This does not alter the current HEAD, index or Working Tree)r��_resolve_ref_on_create)rYr'r(r�r�r�r�s       r3�createzSymbolicReference.createAs%��L�{�{�4��s�'A�9�e�U[�\�\�\r5�new_pathc���|�|��}|j|kr|Stj�t	|j|��|��}tj�t	|j|j��|j��}tj�|��r�|s�t|d��5}|����	��}ddd��n#1swxYwYt|d��5}|����	��}ddd��n#1swxYwY||krtd|z���tj|��tj�|��}	tj�
|	��stj|	��tj||��||_|S)a7Rename self to a new path

        :param new_path:
            Either a simple name or a full path, i.e. new_name or features/new_name.
            The prefix refs/ is implied for references and will be set as needed.
            In case this is a symbolic ref, there is no implied prefix

        :param force:
            If True, the rename will succeed even if a head with the target name
            already exists. It will be overwritten in that case

        :return: self
        :raise OSError: In case a file at path but a different contents already existsr�NzFile at path %r already exists)r�r(rWrXr4r'r�rdrurerjr��dirname�isdir�makedirs�rename)
r<r�r��new_abs_path�cur_abs_path�fd1�f1�fd2�f2�dnames
          r3r�zSymbolicReference.renameis���$�$�X�.�.���9�� � ��K��w�|�|�H�T�Y��$A�$A�8�L�L���w�|�|�H�T�Y��	�$B�$B�D�I�N�N��
�7�>�>�,�'�'�	$��
S��,��-�-�,�������)�)�+�+�B�,�,�,�,�,�,�,�,�,�,�,����,�,�,�,��,��-�-�,�������)�)�+�+�B�,�,�,�,�,�,�,�,�,�,�,����,�,�,�,���8�8�!�"B�\�"Q�R�R�R�
�I�l�#�#�#������-�-���w�}�}�U�#�#�	��K�����	�	�,��-�-�-���	��s$�'C7�7C;�>C;�'E�E	�E	�common_pathc	#��K�|�|j}t��}tjt	|j|����D]�\}}}d|�tj��vrd�|D��}|rdg|dd�<|D]d}|dkr�	tt||����}	|�
|	�t|j��dzd�����e��|�|��D]<\}
}|�
t|����r|�
|���=t|��D]+}	|�||��V��#t"$rY�(wxYwdS)N�refsc��g|]
}|dk�|��S)r�rM)r��ds  r3�
<listcomp>z1SymbolicReference._iter_items.<locals>.<listcomp>�s��:�:�:��a�6�k�k�1�k�k�kr5rrVr�r8)r��setrW�walkrr1ri�sepr	r�add�replacermrfr@�sortedr�rx)
rYr'r��
rela_paths�root�dirs�files�refs_id�fr��_sha�	rela_pathr(s
             r3�_iter_itemszSymbolicReference._iter_items�s��������2�K��U�U�
�"$��)9�$�/�;�)W�)W�!X�!X�	b�	b��D�$���T�Z�Z���/�/�/�/�:�:�d�:�:�:���(� &�x�D����H��
b�
b���
�%�%��/�	�$��0B�0B�C�C�����x�/�/�0D�T�_�0U�0U�X[�0[�]_�`�`�a�a�a�a�	
b� #�4�4�T�:�:�	*�	*�O�D�)��#�#�C��$4�$4�5�5�
*����y�)�)�)��
�:�&�&�	�	�D�
��m�m�D�$�/�/�/�/�/�/���
�
�
���
����	�	s�
E#�#
E0�/E0�argsc�B�d�|�||��D��S)a�Find all refs in the repository

        :param repo: is the Repo

        :param common_path:
            Optional keyword argument to the path which is to be shared by all
            returned Ref objects.
            Defaults to class specific portion if None assuring that only
            refs suitable for the actual class are returned.

        :return:
            git.SymbolicReference[], each of them is guaranteed to be a symbolic
            ref which is not detached and pointing to a valid ref

            List is lexicographically sorted
            The returned objects represent actual subclasses, such as Head or TagReferencec3�HK�|]}|jtks|j�|V��dSr;)rDr%r�)r��rs  r3r�z/SymbolicReference.iter_items.<locals>.<genexpr>�s8����w�w�a���Pa�Aa�Aa�ij�iv�Aa��Aa�Aa�Aa�Aa�w�wr5)r)rYr'r�r	r�s     r3�
iter_itemszSymbolicReference.iter_items�s'��0x�w�3�?�?�4��=�=�w�w�w�wr5c��|std|z���ddlm}m}m}m}m}|||||tfD]H}	|||��}	|	jtkr|	j	rtd���|	cS#t$rY�EwxYwtd|z���)a&
        :param path: full .git-directory-relative path name to the Reference to instantiate
        :note: use to_full_path() if you only have a partial path of a known Reference Type
        :return:
            Instance of type Reference, Head, or Tag
            depending on the given pathzCannot create Reference from %rr)r+rrrr z"SymbolRef was detached, we drop itz8Could not find reference type suitable to handle path %r)
rxr8r+rrrr r%rDr�)
rYr'r(r+rrrr �ref_type�instances
          r3r�zSymbolicReference.from_path�s����	G��>��E�F�F�F�	K�J�J�J�J�J�J�J�J�J�J�J�J�J�
������

�	�	�H�	
�#�8�D�$�/�/���%�):�:�:�x�?S�:�$�%I�J�J�J�#�O�O�O���
�
�
���
�����S�VZ�Z�[�[�[s�3A)�)
A6�5A6c�`�t|j���|jdz��S)zB:return: True if this symbolic reference points to a remote branchr�)r@r(rf�_remote_common_path_defaultrAs r3�	is_remotezSymbolicReference.is_remote�s&���4�9�~�~�(�(��)I�C�)O�P�P�Pr5)F)r)rr;)r)r%)r)r)r+NF)?rE�
__module__�__qualname__�__doc__�	__slots__r�r�r�r�_id_attribute_r�boolr=r@rBrFr�rKrN�intrQ�propertyr2rT�classmethodrZrrrmrrrrrprr�r�rr�r�r�r�r��__annotations__r�r�r�r�r��bytesr�r�r�r�rr$r�rr�r�rr
r�rrMr5r3r%r%:sj�������;�;�!�I�"��"����"0���N���V��8�������������F�#�F�F�F�F��F��t�����#�F�#�t�#�#�#�#��#�������c�����X���K��K�K�K��X�K��<��<�C�<�<�<��[�<�� �V� ���s�C�x��0I� � � ��[� �N�	��	�5��4��;P�	�UX�	�	�	��[�	��&U��&U�%*�8�T�>�%:�&U�	�u�S�$�Y���t�S�y�!1�1�	2�&U�&U�&U��[�&U�P�8��8�5��4��3H�8�U�SX�Y\�^b�Yb�Sc�ej�ko�qt�kt�eu�Su�Mv�8�8�8��[�8�l�Z�l�l�l�l�
�
�
�
�$$(����f�1�3�6�7���c�4�i� ��
�	����H$(�@�@��j�"5�s�:�;�@��c�4�i� �@�
�	@�@�@�@�>�X�k�:�3R�
S�
S�
S�F�
�X�k�:�3b�
c�
c�
c�F�:�:�:�:�$(�G�G�
�:�2�C�7�
8�G��c�4�i� �G�
�	G�G�G�G�T�K�L�L�L�L�����<_�`�`�`�I�
�C�
�$�
�
�
�
��	�T�	�	�	��X�	�3�3�3�3�)-�	j�j��j��s�D�y�!�j�����%�	j�

�j�j�j�j�:9�s�9�}�9�9�9�9����h�0C�&C� D�������[���7#�&�7#��7#�T�7#�7#�7#��[�7#�t�$(�(�(�
�,�
�(��(��(��	(�
�,�c�1�2�(��
(��c�4�i� �(�
�(�(�(��[�(�T�
6<�#'��
%]�%]�
�,�
�%]��%]��%]��,�c�1�2�	%]�
�c�4�i� �%]��
%]��%]�
�%]�%]�%]��[�%]�N+�+�x�+��+�AT�+�+�+�+�Z�TX�$�$�
�,�
�$�'-�$�<A�(�D�.�<Q�$�	�,�	�$�$�$��[�$�N�.2�x�x�
�,�
�x��x��8�T�>�*�x��	x�
�x�
�,�	�
x�x�x��[�x�2�"\�t�L�)�"\��"\�x�"\�L�"\�"\�"\��[�"\�HQ�4�Q�Q�Q�Q�Q�Qr5)0�	git.typesrrW�
git.compatr�git.objectsr�git.objects.commitr�git.utilrrr	r
rr�	gitdb.excr
rr�r�typingrrrrrrrrrr�git.repor�git.refsrrrr r!�
git.configr"r#r$�__all__r4r�r%rMr5r3�<module>r*si��������	�	�	�	�������������%�%�%�%�%�%�����������������)�(�(�(�(�(�(�(�������
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�+�*�*�*�*�*�*�*��)�������G�G�G�G�G�G�G�G�G�G�G�G� � � � � � �*�*�*�*�*�*�(�(�(�(�(�(��w�~�-@�A�A�A��
�
���6���x��~�!6��8�����EQ�EQ�EQ�EQ�EQ��EQ�EQ�EQ�EQ�EQr5

Zerion Mini Shell 1.0