File manager - Edit - /opt/saltstack/salt/lib/python3.10/site-packages/git/refs/__pycache__/symbolic.cpython-310.pyc
Back
o ;j+� � @ s2 d gZ ddlZddlmZ ddlmZmZ ddlmZ ddl m Z ddl m Z ddl mZ dd lmZmZmZmZmZmZ dd lmZmZmZmZmZm Z m Z m Z m Z dd l m!Z!m"Z" er{dd l#m$Z$ dd l m%Z% ddl m&Z& ddl'm(Z( ddl)m*Z* e dd d�Z+ddde e"df de"fdd�Z,G dd � d �Z-dS )�SymbolicReference� N)�Path)�BadName� BadObject)�defenc)�Object)�Commit)�RefLog)�LockedFD�assure_directory_exists� hex_to_bin� join_path�join_path_native�to_native_path_linux) �Any�Iterator�List� TYPE_CHECKING�Tuple�Type�TypeVar�Union�cast)� AnyGitObject�PathLike)�GitConfigParser)�Actor)� RefLogEntry)� Reference)�Repo� T_References)�bound�repor �path�returnc C s |� }|dv r | j S | jS )z2Find the git dir that is appropriate for the path.)�HEADZ ORIG_HEADZ FETCH_HEAD�index�logs)�git_dir� common_dir)r" r# �name� r+ �E/opt/saltstack/salt/lib/python3.10/site-packages/git/refs/symbolic.py�_git_dir5 s r- c @ s e Zd ZdZdZdZdZdZdZdZ dydd d e d e d d fdd�Z d e fdd�Zd e fdd�Zded e fdd�Zded e fdd�Zd efdd�Zed e fdd ��Zed e fd d ��Zed e d e d e fd d!��Zedd d e d e fd"d#��Zedd d e d e fd$d%��Z edd d e fd&d'��Z edd d e e e e f fd(d)��Z edd d*e!e d f d e fd+d,��Z"ed*e d d fd-d.��Z#edd d*e!e d f d e!e e d f e d e f f fd/d0��Z$edd d*e!e d f d e!e e d f e d e f f fd1d2��Z%d e&fd3d4�Z'dzd6d7�Z( d{d8e!e)d e f d9e!e d f d d fd:d;�Z* d{d<e!e&d e f d9e!e d f d d fd=d>�Z+edzd?d@��Z,e,j-d8e!e)d e f d d fdAd@��Z,ed e&fdBdC��Zej-d<e!e&d e f d d fdDdC��Zd|dFdG�Z. d{dHe!e&d e f d9e!e d f d d fdIdJ�Z/ed|dKdL��Z0e0j-dHe!e&d e f d d fdMdL��Z0e0Z1d e fdNdO�Z2ed e fdPdQ��Z3d}dSdT�Z4 d{dUe5dVe!e d f dWe!e5d f d dXfdYdZ�Z6d[ed dXfd\d]�Z7ed e!e d f d e fd^d_��Z8edd d e d d fd`da��Z9e d{dbe:e; dd d e dce dde!d e f dee d9e!e d f d e;fdfdg��Z<e h d~dbe:e; dd d e dde!d e f d9e!e d f dee die=d e;fdjdk��Z>dydle dee d d fdmdn�Z?e d{dbe:e; dd doe!e d f d e e; fdpdq��Z@e d{dbe:e; dd doe!e d f dre=die=d e e; f dsdt��ZAedbe:e; dd d e d e;fdudv��ZBd e fdwdx�ZCd S )r a Special case of a reference that is symbolic. This does not point to a specific commit, but to another :class:`~git.refs.head.Head`, which itself specifies a commit. A typical example for a symbolic reference is :class:`~git.refs.head.HEAD`. �r" r# FT� z refs/remotesr* r" r r# � check_pathr$ Nc C s || _ || _d S �Nr. )�selfr" r# r0 r+ r+ r, �__init__N s zSymbolicReference.__init__c C � t �| j�S r1 ��os�fspathr# �r2 r+ r+ r, �__str__R s zSymbolicReference.__str__c C s d| j j| jf S )Nz <git.%s "%s">)� __class__�__name__r# r8 r+ r+ r, �__repr__U s zSymbolicReference.__repr__�otherc C s$ t |d�rtt|�}| j|jkS dS )Nr# F)�hasattrr r r# �r2 r= r+ r+ r, �__eq__X s zSymbolicReference.__eq__c C s | |k S r1 r+ r? r+ r+ r, �__ne__^ � zSymbolicReference.__ne__c C s t | j�S r1 )�hashr# r8 r+ r+ r, �__hash__a rB zSymbolicReference.__hash__c C r4 )z� :return: In case of symbolic references, the shortest assumable name is the path itself. r5 r8 r+ r+ r, r* d s zSymbolicReference.namec C s t t| j| j�| j�S r1 )r r- r" r# r8 r+ r+ r, �abspathm s zSymbolicReference.abspath�basec C s� t �|�}t j�t �| ��}t j�t j�||��}z t j�||g�}W n ty6 } ztd| �|�d }~ww t j�|�t j�|�krItd| ��|S )Nz(Reference path %r escapes the repository)r6 r7 r# �realpath�join� commonpath� ValueError�normcase)rF r# � base_path�abs_path� common_path�er+ r+ r, �_get_validated_pathq s �� z%SymbolicReference._get_validated_pathc C s& | � |� t�|�}| �t||�|�S )zBReturn the absolute filesystem path for a ref after validating it.)�_check_ref_name_validr6 r7 rP r- )�clsr" r# �ref_pathr+ r+ r, �_get_validated_ref_path~ s z)SymbolicReference._get_validated_ref_pathc C s" | � |� | �tj�|jd�|�S )zEReturn the absolute filesystem path for a reflog after validating it.r' )rQ rP r6 r# rH r( )rR r" r# r+ r+ r, �_get_validated_reflog_path� s z,SymbolicReference._get_validated_reflog_pathc C s t j�|jd�S )N� packed-refs)r6 r# rH r) )rR r" r+ r+ r, �_get_packed_refs_path� s z'SymbolicReference._get_packed_refs_pathc c s� � zWt | �|�ddd��B}|D ]5}|�� }|sq|�d�r-|�d�r,d|vr,td| ��q|d d kr4qttttf t|� d d ���V qW d � W d S 1 sQw Y W d S t yb Y d S w ) z�Return 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:Zpeeledz-PackingType of packed-Refs not understood: %rr �^� � N) �openrW �strip� startswith� TypeErrorr r �str�tuple�split�OSError)rR r" �fp�liner+ r+ r, �_iter_packed_refs� s& � "�&� �z#SymbolicReference._iter_packed_refsrS c C s | � ||�\}}|dur|S q)a :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`. TN)� _get_ref_info)rR r" rS �hexshar+ r+ r, �dereference_recursive� s �z'SymbolicReference.dereference_recursivec C sx d}d}t �| �D ]t}|dv rtd| � d���|dkr8|du s#|dkr+td| � d���|dkr7td| � d���nA|dkrU|dkrHtd| � d ���|du rTtd| � d ���n$|d kre|d kretd| � d ���t|�dk sqt|�dkrytd| � d���|}|}q |dkr�td| � d���|dkr�td| � d���|d kr�|du r�td| � d���tdd� t| �jD ��r�td| � d���dS )z|Check a ref name for validity. This is based on the rules described in :manpage:`git-check-ref-format(1)`. Nz ~^:?*[\zInvalid reference 'z�': references cannot contain spaces, tildes (~), carets (^), colons (:), question marks (?), asterisks (*), open brackets ([) or backslashes (\)�.�/z<': references cannot start with a period (.) or contain '/.'z!': references cannot contain '..'z!': references cannot contain '//'z3': references cannot start with forward slashes '/'�{�@z!': references cannot contain '@{'� � z5': references cannot contain ASCII control charactersz*': references cannot end with a period (.)z1': references cannot end with a forward slash (/)z': references cannot be '@'c s s � | ]}|� d �V qdS )z.lockN)�endswith)�.0Z componentr+ r+ r, � <genexpr>� � � z:SymbolicReference._check_ref_name_valid.<locals>.<genexpr>zJ': references cannot have slash-separated components that end with '.lock')r6 r7 rJ �ord�anyr �parts)rS ZpreviousZone_before_previous�cr+ r+ r, rQ � sP � �� �� ��z'SymbolicReference._check_ref_name_validc C s |r| � |� d}t||�}z0ttj�||�ddd��}|�� �� }W d � n1 s,w Y |�� }t |�dks=J �W n t yZ | � |�D ] \}}||krSqJ||f} Y nw |du ret d| ��|d dkrqd|d fS |j �|d �r|d dfS t d | ��) �� :return: *(str(sha), str(target_ref_path))*, where: * *sha* is of the file at rela_path points to if available, or ``None``. * *target_ref_path* is the reference we point to, or ``None``. NrX rY rZ r z Reference at %r does not existzref:r_ z-Failed to parse reference information from %r)rQ r- r` r6 r# rH �read�rstriprf �lenrg rj rJ Zre_hexsha_only�match) rR r" rS �tokensZrepodirrh �value�shar# r+ r+ r, �_get_ref_info_helper� s2 � �� z&SymbolicReference._get_ref_info_helperc C s | � ||�S )r| )r� )rR r" rS r+ r+ r, rk ( s z SymbolicReference._get_ref_infoc C s t �| 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 Z new_from_shar" r rm r# r8 r+ r+ r, � _get_object3 s z SymbolicReference._get_objectr c C s4 | � � }|jdkr |j}|jtjkrtd| ��|S )z� :return: :class:`~git.objects.commit.Commit` object we point to. This works for detached and non-detached :class:`SymbolicReference` instances. The symbolic reference will be dereferenced recursively. �tagz<Symbolic Reference pointed to object %r, commit was required)r� �type�objectr rc )r2 �objr+ r+ r, � _get_commit= s z SymbolicReference._get_commit�commit�logmsgc C s� d}t |t�r|jtjk}n/t |t�r|jjtjk}n"z | j�|�jtjk}W n tt fy< } zt d| �|�d}~ww |rEt d| ��| � ||� | S )a. Like :meth:`set_object`, but restricts the type of object to be a :class:`~git.objects.commit.Commit`. :raise ValueError: If `commit` is not a :class:`~git.objects.commit.Commit` object, nor does it point to a commit. :return: self FzInvalid object: %sNzNeed commit, got %r) � isinstancer r� r r r� r" � rev_parser r rJ � set_object)r2 r� r� Z invalid_typerO r+ r+ r, � set_commitN s �� z SymbolicReference.set_commitr� c C sR t |t�r|j}d}z| j}W n ty Y nw |r!| �||�S | �� �||�S )ax Set 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 :class:`SymbolicReference` or an :class:`~git.objects.base.Object` instance. * :class:`SymbolicReference` instances will be dereferenced beforehand to obtain the git object they point to. * :class:`~git.objects.base.Object` instances must represent git objects (:class:`~git.types.AnyGitObject`). :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 :class:`SymbolicReference` instances may not actually point to objects by convention. :return: self T)r� r r� � is_detachedrJ � set_reference�_get_referencer� )r2 r� r� r� r+ r+ r, r� t s � z SymbolicReference.set_objectc C � | � � S )z Query or set commits directly)r� r8 r+ r+ r, r� � � zSymbolicReference.commitc C � | � |�S r1 )r� )r2 r� r+ r+ r, r� � � c C r� )z-Return the object our ref currently refers to)r� r8 r+ r+ r, r� � r� zSymbolicReference.objectc C r� r1 )r� )r2 r� r+ r+ r, r� � r� r c C s@ | � | j| j�\}}|du rtd| |f ��td| �| j|��S )z� :return: :class:`~git.refs.reference.Reference` object we point to :raise TypeError: If this symbolic reference is detached, hence it doesn't point to a reference, but to a commit. Nz6%s is a detached symbolic reference as it points to %rr )rk r" r# rc r � from_path)r2 r� Ztarget_ref_pathr+ r+ r, r� � s z SymbolicReference._get_reference�refc C sl d}d}t |t�rd|j }n9t |t�r|}|j}n.t |t�rBz | j�|d �}|j}W n tt fyA } zt d| �|�d}~ww t d| ��|dur[| j r[|j t j kr[td| ��d}|durtz| jj}W n t ys t j}Y nw | �| j| j�}t|dd � t|�}|jddd �} z| �|�d �d � |�� W n ty� |�� � w |dur�| �||� | S ) a� Set ourselves to the given `ref`. It will stay a symbol if the `ref` is a :class:`~git.refs.reference.Reference`. Otherwise a git object, specified as a :class:`~git.objects.base.Object` instance or refspec, is assumed. If it is valid, this reference will be set to it, which effectively detaches the reference if it was a purely symbolic one. :param ref: A :class:`SymbolicReference` instance, an :class:`~git.objects.base.Object` instance (specifically an :class:`~git.types.AnyGitObject`), or a refspec string. Only if the ref is a :class:`SymbolicReference` 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: :meth:`log_append` :return: self :note: This symbolic reference will not be dereferenced. For that, see :meth:`set_object`. Nzref: %sz^{}z Could not extract object from %szUnrecognized Value: %rzRequire commit, got %r� T)�is_file)�write�streamzutf-8� )r� r r# r rl rd r" r� r r rJ �_points_to_commits_onlyr� r rc r� �binshaZ NULL_BIN_SHArT r r r` r� �encode� BaseExceptionZrollback� log_append) r2 r� r� Z write_valuer� rO � oldbinshaZfpathZlfd�fdr+ r+ r, r� � sN ! �� � � z SymbolicReference.set_referencec C r� r1 )r� r8 r+ r+ r, � reference s zSymbolicReference.referencec C r� r1 )r� )r2 r� r+ r+ r, r� r� c C s& z| j W dS ttfy Y dS w )z� :return: ``True`` if the reference is valid, hence it can be read and points to a valid object or reference. FT)r� rg rJ r8 r+ r+ r, �is_valid s ��zSymbolicReference.is_validc C s" z| j W dS ty Y dS w )z� :return: ``True`` if we are a detached reference, hence we point to a specific commit instead to another reference. FT)r� rc r8 r+ r+ r, r� + s �z SymbolicReference.is_detachedr c C s t �t �| ��S )ad :return: :class:`~git.refs.log.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 Z from_filer# r8 r+ r+ r, �log8 s zSymbolicReference.logr� �message� newbinshar c C s^ z| j j}W n ty | j�� }Y nw |du r | j j}|du r#d}t�|t�| �|||�S )a� Append 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: The added :class:`~git.refs.log.RefLogEntry` instance. Nr/ ) r� Z committerrJ r" Z config_readerr� r Z append_entryr# )r2 r� r� r� Zcommitter_or_readerr+ r+ r, r� D s �z SymbolicReference.log_appendr& c C s t �t �| �|�S )a� :return: :class:`~git.refs.log.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 sparingly, or only if you need just one index. In that case, it will be faster than the :meth:`log` method. )r Zentry_atr# )r2 r& r+ r+ r, � log_entryh s zSymbolicReference.log_entryc C sF t |t�r|j}|}| js|S t�|��| jd �s!d| j|f }|S )a :return: String with a full repository-relative path which can be used to initialize a :class:`~git.refs.reference.Reference` instance, for instance by using :meth:`Reference.from_path <git.refs.reference.Reference.from_path>`. ro z%s/%s)r� r r# �_common_path_defaultr6 r7 rb )rR r# � full_ref_pathr+ r+ r, � to_full_pathw s z SymbolicReference.to_full_pathc C s^ | � |�}| �||�}tj�|�rt�|� n�| �|�}zrt|d��B}g }d}d} |D ]1} | �t �} | � d�\} } } | � � } | � d�sG|| krX| rP| rX| � d�sX|� | � d} q+d}d} q+W d � n1 sgw Y |r�t|d��}|�d d � |D �� W d � n1 s�w Y W n ty� Y nw t�| ||��}tj�|�r�t�|� dS dS ) af Delete the reference at the given path. :param repo: Repository to delete the reference from. :param path: Short or full path pointing to the reference, e.g. ``refs/myreference`` or just ``myreference``, hence ``refs/`` is implied. Alternatively the symbolic reference to be deleted. �rbFr^ r\ r] TN�wbc s s � | ]}|� t�V qd S r1 )r� r )ru ri r+ r+ r, rv � rw z+SymbolicReference.delete.<locals>.<genexpr>)r� rT r6 r# �exists�removerW r` �decoder � partitionra rb �append� writelinesrg r �isfile)rR r" r# r� rM Zpack_file_path�readerZ new_linesZ made_changeZdropped_last_lineZ line_bytesri �_Zline_refr� Z reflog_pathr+ r+ r, �delete� sP ��� � � �� � �zSymbolicReference.deleterR �resolver� �forcec C s� | � |�}| �||�}|} |r|�t|��} |s^tj�|�r^t| �} t| t�r-t� | j�} |s3d| } t |d��} | � � � t ��� } W d � n1 sLw Y | | kr^td|| | f ��| ||�} | �| |� | S )a3 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 instead. zref: r� NzDReference at %r does already exist, pointing to %r, requested was %r)r� rT r� rd r6 r# r� r� r r7 r` r} r� r ra rg r� )rR r" r# r� r� r� r� r� Z abs_ref_path�targetZ target_datar� Z existing_datar� r+ r+ r, �_create� s. ��� zSymbolicReference._creater% �kwargsc K s | � ||| j|||�S )aF Create a new symbolic reference: 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, e.g. ``NEW_HEAD`` or ``symrefs/my_new_symref``. :param reference: The reference 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 :exc:`OSError` otherwise. :param logmsg: If not ``None``, the message to append to the reflog. If ``None``, 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)rR r" r# r� r� r� r� r+ r+ r, �create� s )zSymbolicReference.create�new_pathc C s | � |�}| j|kr | S | �| j|�}| �| j| j�}tj�|�rh|sct|d��}|�� �� }W d � n1 s9w Y t|d��}|�� �� }W d � n1 sTw Y ||krct d| ��t� |� tj� |�} tj� | �syt� | � t�||� || _| S )aw Rename self to a new path. :param new_path: Either a simple name or a full path, e.g. ``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: If a file at path but with different contents already exists. r� Nz File at path %r already exists)r� r# rT r" r6 r� r` r} ra rg r� �dirname�isdir�makedirs�rename) r2 r� r� Z new_abs_pathZ cur_abs_pathZfd1�f1�fd2�f2Zdnamer+ r+ r, r� s, � � zSymbolicReference.renamerN c c s � |d u r| j }t� }t�t|j|��D ]<\}}}d|�tj�vr1dd� |D �}|r1dg|dd �< |D ] }|dkr:q3tt ||��} |� | � t|j�d d�� q3q| � |�D ]\} } | � t�|��rg|� | � qVt|�D ]} z | �|| �V W ql ty� Y qlw d S )N�refsc S s g | ]}|d kr|�qS )r� r+ )ru �dr+ r+ r, � <listcomp>X s z1SymbolicReference._iter_items.<locals>.<listcomp>r rV ro r/ )r� �setr6 �walkr r) rf �sepr r �add�replacerj rb r7 �sortedr� rJ ) rR r" rN Z rela_paths�root�dirs�filesZrefs_id�frM Z_shaZ rela_pathr# r+ r+ r, � _iter_itemsL s4 � � � ��z SymbolicReference._iter_items�argsc O s dd� | � ||�D �S )a Find all refs in the repository. :param repo: The :class:`~git.repo.base.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``, ensuring that only refs suitable for the actual class are returned. :return: A list of :class:`SymbolicReference`, each guaranteed to be a symbolic ref which is not detached and pointing to a valid ref. The list is lexicographically sorted. The returned objects are instances of concrete subclasses, such as :class:`~git.refs.head.Head` or :class:`~git.refs.tag.TagReference`. c s s$ � | ] }|j tu s |js|V qd S r1 )r: r r� )ru �rr+ r+ r, rv � s �" z/SymbolicReference.iter_items.<locals>.<genexpr>)r� )rR r" rN r� r� r+ r+ r, � iter_itemst s z SymbolicReference.iter_itemsc C s� |st d| ��ddlm}m}m}m}m} |||||tfD ]$}ztt |||��} | j tu r5| j r5t d��| W S t yB Y q w t d| ��)a� Make a symbolic reference from a path. :param path: Full ``.git``-directory-relative path name to the Reference to instantiate. :note: Use :meth:`to_full_path` if you only have a partial path of a known Reference type. :return: Instance of type :class:`~git.refs.reference.Reference`, :class:`~git.refs.head.Head`, or :class:`~git.refs.tag.Tag`, depending on the given path. z Cannot create Reference from %rr_ )r% �Head�RemoteReference� TagReferencer z$SymbolicRef was detached, we drop itz8Could not find reference type suitable to handle path %r) rJ r/ r% r� r� r� r r r r r: r� ) rR r" r# r% r� r� r� r Zref_type�instancer+ r+ r, r� � s& � � zSymbolicReference.from_pathc C s t �| j��| jd �S )zB:return: True if this symbolic reference points to a remote branchro )r6 r7 r# rb �_remote_common_path_defaultr8 r+ r+ r, � is_remote� s zSymbolicReference.is_remote)F)r$ r r1 )r$ r )r$ r )r% NF)Dr; � __module__� __qualname__�__doc__� __slots__r� r� r� r� Z_id_attribute_r �boolr3 rd r9 r< r� r@ rA �intrD �propertyr* rE � staticmethodrP � classmethodrT rU rW r r rj r rm rQ r� rk r r� r� r r� r� r� �setterr� r� r� r� r� r� r� �bytesr� r� r� r� r r r� r r� r� r� r� r� r� r+ r+ r+ r, r = sV ' /� � �/8 � � � �)� � � �- � � � �S �� � � �$ ;����� �� � �*���� � ��� �*2��� � �'��� ��� � +).�__all__r6 �pathlibr Z gitdb.excr r Z git.compatr Zgit.objects.baser Zgit.objects.commitr Z git.refs.logr Zgit.utilr r r r r r �typingr r r r r r r r r Z git.typesr r Z git.configr r r Zgit.refs.referencer Zgit.repor r r- r r+ r+ r+ r, �<module> s( ,
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings