o ﯪg@s2dgZddlZddlmZmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZmZdd lmZmZmZmZmZmZmZmZmZdd lmZm Z er{dd l!m"Z"dd l m#Z#dd l$m%Z%m&Z&m'Z'm(Z(ddl m)Z)ddl*m+Z+edddZ,dddee dfde fddZ-GdddZ.dS)SymbolicReferenceN)BadName BadObject)defenc)Object)Commit)RefLog)LockedFDassure_directory_exists hex_to_bin join_pathjoin_path_nativeto_native_path_linux) AnyIteratorList TYPE_CHECKINGTupleTypeTypeVarUnioncast) AnyGitObjectPathLike)GitConfigParser)ActorHead TagReferenceRemoteReference Reference) RefLogEntry)Repo T_References)boundrepor"pathreturncCs|}|dvr |jS|jS)z2Find the git dir that is appropriate for the path.)HEAD ORIG_HEAD FETCH_HEADindexlogs)git_dir common_dir)r%r&namer0M/var/www/html/chatdoc2/venv/lib/python3.10/site-packages/git/refs/symbolic.py_git_dir4sr2c@sbeZdZUdZdZdZdZdZdZdZ dmdd d e d e d d fddZ d e fddZd e fddZded e fddZded e fddZd efddZed e fddZed e fddZedd d e fdd Zedd d eee e ffd!d"Zedd d#ee d fd e fd$d%Zed#e d d fd&d'Z edd d#ee d fd eee d fed e fffd(d)Z!edd d#ee d fd eee d fed e fffd*d+Z"d e#fd,d-Z$dnd/d0Z% dod1ee&de fd2ee d fd dfd3d4Z' dod5ee#de fd2ee d fd dfd6d7Z(ee%e'd8d9Z)ee$e(d:d9Zdpd;d<Z* dod=ee#de fd2ee d fd dfd>d?Z+ed@e,dA<ee*e+dBd9Z-e-Z.d e fdCdDZ/ed e fdEdFZ0dqdHdIZ1 dodJe2dKee d fdLee2d fd dMfdNdOZ3dPed dMfdQdRZ4ed ee dfd e fdSdTZ5edd d e d d fdUdVZ6e dodWe7e8dd d e dXe dAede fdYe d2ee d fd e8fdZd[Z9e \ drdWe7e8dd d e dAede fd2ee d fdYe d]e:d e8fd^d_Z;dmd`e dYe d dfdadbZedWe7e8dd d e d e8fdidjZ?d e fdkdlZ@d S)sraSpecial 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&FTz refs/remotesr/r%r"r& check_pathr'NcCs||_||_dSNr3)selfr%r&r5r0r0r1__init__Ms zSymbolicReference.__init__cC t|jSr6strr&r7r0r0r1__str__Q zSymbolicReference.__str__cCsd|jj|jfS)Nz ) __class____name__r&r<r0r0r1__repr__TszSymbolicReference.__repr__othercCs$t|drtt|}|j|jkSdS)Nr&F)hasattrrrr&r7rBr0r0r1__eq__Ws   zSymbolicReference.__eq__cCs ||k Sr6r0rDr0r0r1__ne__]r>zSymbolicReference.__ne__cCr9r6)hashr&r<r0r0r1__hash__`r>zSymbolicReference.__hash__cCr9)z :return: In case of symbolic references, the shortest assumable name is the path itself. r:r<r0r0r1r/cs zSymbolicReference.namecCstt|j|j|jSr6)r r2r%r&r<r0r0r1abspathlzSymbolicReference.abspathcCstj|jdS)N packed-refs)osr&joinr.)clsr%r0r0r1_get_packed_refs_pathpsz'SymbolicReference._get_packed_refs_pathc cszWt||dddB}|D]5}|}|sq|dr-|dr,d|vr,td|q|dd kr4qttttft| d d VqWd Wd S1sQwYWd St ybYd Sw) zReturn 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. rtUTF-8encoding#z# pack-refs with:peeledz-PackingType of packed-Refs not understood: %rr^ N) openrOstrip startswith TypeErrorrrr;tuplesplitOSError)rNr%fpliner0r0r1_iter_packed_refsts&   "& z#SymbolicReference._iter_packed_refsref_pathcCs |||\}}|dur|Sq)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)rNr%rchexshar0r0r1dereference_recursives  z'SymbolicReference.dereference_recursivecCszd}d}t|D]t}|dvrtd|d|dkr7|dus"|dkr*td|d|dkr6td|dnA|dkrT|dkrGtd|d |durStd|d n$|d krd|d krdtd|d t|dkspt|dkrxtd|d|}|}q|dkrtd|d|dkrtd|d|d kr|durtd|dtddt|dDrtd|ddS)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 '@'css|]}|dVqdS)z.lockN)endswith).0 componentr0r0r1 z:SymbolicReference._check_ref_name_valid..zJ': references cannot have slash-separated components that end with '.lock')r; ValueErrorordanyr^)rcpreviousone_before_previouscr0r0r1_check_ref_name_validsP     z'SymbolicReference._check_ref_name_validc Cs|r||d}t||}z2ttj|t|ddd}|}Wdn1s.wY| }t |dks?JWnt y\| |D] \}}||krUqL||f}Ynw|durgt d||ddkrsd|dfS|j|dr|ddfSt 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``. NrPrQrRrzReference at %r does not existzref:rXz-Failed to parse reference information from %r)rxr2rYrLr&rMr;readrstripr^lenr_rbrrre_hexsha_onlymatch) rNr%rctokensrepodirr`valueshar&r0r0r1_get_ref_info_helpers2        z&SymbolicReference._get_ref_info_helpercCs |||S)ry)r)rNr%rcr0r0r1rd s zSymbolicReference._get_ref_infocCst|jt||j|jS)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%r rfr&r<r0r0r1 _get_objectszSymbolicReference._get_objectrcCs4|}|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`. rhz%s/%s)rrr&_common_path_defaultr;r[)rNr& full_ref_pathr0r0r1 to_full_pathTs zSymbolicReference.to_full_pathcCsb||}tj|j|}tj|rt|n||}zrt|dB}g}d}d} |D]1} | t } | d\} } } | } | dsI|| krZ| rR| rZ| dsZ|| d} q-d}d} q-Wdn1siwY|rt|d}|d d |DWdn1swYWn tyYnwt|||}tj|rt|dSdS) afDelete 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. rbFrWrTrVTNwbcss|]}|tVqdSr6)rr)rnrar0r0r1rprqz+SymbolicReference.delete..)rrLr&rMr.existsremoverOrYdecoder partitionrZr[append writelinesr_risfile)rNr%r&rabs_pathpack_file_pathreader new_lines made_changedropped_last_line line_bytesra_line_refr reflog_pathr0r0r1deleteesP          zSymbolicReference.deleterNresolveforcecCst||}||}tj||} |} |r|t|} |sctj| rct| } t| t r2t| j} |s8d| } t | d} | t } Wdn1sQwY| | krctd|| | f|||}|| ||S)a3Internal 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: rNzDReference at %r does already exist, pointing to %r, requested was %r)r2rrLr&rMrr;rrrrYrzrrrZr_r)rNr%r&rrrrr-r abs_ref_pathtarget target_datar existing_datarr0r0r1_creates0       zSymbolicReference._creater(kwargscKs||||j|||S)aFCreate 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)rNr%r&rrrrr0r0r1creates)zSymbolicReference.createnew_pathc Cs||}|j|kr |Stjt|j||}tjt|j|j|j}tj|rq|slt|d}| }Wdn1sBwYt|d}| }Wdn1s]wY||krlt d|t |tj |} tj | st| t||||_|S)awRename 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. rNzFile at path %r already exists)rr&rLrMr2r%rrYrzrZr_rdirnameisdirmakedirsrename) r7rr new_abs_path cur_abs_pathfd1f1fd2f2dnamer0r0r1rs,           zSymbolicReference.rename common_pathc cs|dur|j}t}tt|j|D]<\}}}d|tjvr1dd|D}|r1dg|dd<|D]}|dkr:q3tt ||} | | t|jddq3q| |D]\} } | t|rf| | qVt|D]} z ||| VWqktyYqkwdS)NrefscSsg|]}|dkr|qS)rr0)rndr0r0r1 6sz1SymbolicReference._iter_items..rrKrhr4)rsetrLwalkr r.r^seprr addreplacerbr[r;sortedrrr) rNr%r rela_pathsrootdirsfilesrefs_idfr_sha rela_pathr&r0r0r1 _iter_items*s4    zSymbolicReference._iter_itemsargscOsdd|||DS)aFind 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`. css$|] }|jtus |js|VqdSr6)r?rr)rnrr0r0r1rpms"z/SymbolicReference.iter_items..)r)rNr%rrrr0r0r1 iter_itemsRszSymbolicReference.iter_itemsc Cs|std|ddlm}m}m}m}m}|||||tfD]!}z|||} | jtur2| j r2td| WSty?Yqwtd|)aMake 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. zCannot create Reference from %rrX)r(rrrr z$SymbolicRef was detached, we drop itz8Could not find reference type suitable to handle path %r) rrr4r(rrrr rr?r) rNr%r&r(rrrr ref_typeinstancer0r0r1ros&     zSymbolicReference.from_pathcCst|j|jdS)zB:return: True if this symbolic reference points to a remote branchrh)r;r&r[_remote_common_path_defaultr<r0r0r1 is_remoterJzSymbolicReference.is_remote)F)r'rr6)r'r)r'r)r(NF)Ar@ __module__ __qualname____doc__ __slots__rrrr_id_attribute_rboolr8r;r=rArrErFintrHpropertyr/rI classmethodrOrrrbrrf staticmethodrxrrdrrrrrrrrr__annotations__rrrrrbytesrrrrrr#rrrrrrrrr0r0r0r1r<sR  ' /  /8    )   -    S     $;   +   *2  '   ,)/__all__rL gitdb.excrr git.compatrgit.objects.basergit.objects.commitr git.refs.logrgit.utilr r r r r rtypingrrrrrrrrr git.typesrr git.configrrgit.refsrrrr r!git.repor"r#r2rr0r0r0r1s&     ,