r%"E b d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl m
Z
m Z m Z m
Z
mZmZ d dlmZmZ dd lmZ d d
lmZmZmZmZmZmZm Z m Z m Z d d l m Z mZ e r$d d l m!Z! d d
l"m#Z#m$Z$m%Z%m&Z& ddlm'Z' d dl(m)Z) d dlm*Z* edd Z+dgZ,ddde edf defdZ- G d de. Z/dS ) )PathLikeN)defenc)Object)Commit) join_pathjoin_path_nativeto_native_path_linuxassure_directory_exists
hex_to_binLockedFD) BadObjectBadName )RefLog) AnyIteratorListTupleTypeTypeVarUnion
TYPE_CHECKINGcast)
Commit_ishr )RepoHead TagReferenceRemoteReference Reference) RefLogEntry)GitConfigParser)Actor T_ReferencesSymbolicReference)boundrepor pathreturnc , | }|dv r| j S | j S )z0Find the git dir that's appropriate for the path)HEAD ORIG_HEAD
FETCH_HEADindexlogs)git_dir
common_dir)r' r( names c/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/git/refs/symbolic.py_git_dirr4 2 s% 9D CCC| ? c e Zd ZU dZdZdZdZdZdZdZ dJdd d
e
d e fd Z d
e
fdZd
e
fdZded
e fdZded
e fdZd
efdZed
e
fd Zed
e
fd Zedd d
e
fd Zedd d
eee
e
f fd Z edd de e
df d
e
fd Z edd de e
df d
e ee
df ede
f f fd Z edd de e
df d
e ee
df ede
f f fd Z d
e!fd Z"dKd Z# dLd e e$d e
f d!e e
df d
d fd"Z% dLd#e e!d e
f d!e e
df d
d fd$Z& ee#e%d%& Z' ee"e&d'& ZdMd(Z( dLd)e e!d e
f d!e e
df d
d fd*Z)e d+ e*d,< ee(e)d-& Z+e+Z,d
e fd.Z-ed
e fd/ Z.dNd1Z/ dLd2e0d3e e
df d4e e0df d
d5fd6Z1d7ed
d5fd8Z2ed
e e
d f d
e
fd9 Z3edd d
e
d
dfd: Z4e dLd;e5e6 dd d
e
d Z7e dOd;e5e6 dd d
e
d,e d e
f d!e e
df d=e d@e8d
e6fdA Z9dJdBe
d=e d
d fdCZ:e dLd;e5e6 dd dDe e
df d
ee6 fdE Z;e dLd;e5e6 dd dDe e
df dFe8d@e8d
ee6 f dG ZdS )Pr% zRepresents 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/remotesr2 r' r r(
check_pathc " || _ || _ d S Nr7 )selfr' r( r9 s r3 __init__zSymbolicReference.__init__I s r5 r) c * t | j S r; strr( r< s r3 __str__zSymbolicReference.__str__M s 49~~ r5 c 2 d| j j d| j dS )Nz) __class____name__r( rA s r3 __repr__zSymbolicReference.__repr__P s "&."9"9"94999EEr5 otherc p t |d r%t t | }| j |j k S dS )Nr( F)hasattrr r% r( r< rG s r3 __eq__zSymbolicReference.__eq__S s8 5& ! ! +*E22E9
* *ur5 c | |k S r; rJ s r3 __ne__zSymbolicReference.__ne__Y s EM""r5 c * t | j S r; )hashr( rA s r3 __hash__zSymbolicReference.__hash__\ s DI r5 c * t | j S )zy
:return:
In case of symbolic references, the shortest assumable name
is the path itself.r? rA s r3 r2 zSymbolicReference.name_ s 49~~ r5 c \ t t | j | j | j S r; )r r4 r' r( rA s r3 abspathzSymbolicReference.abspathg s" DI > > JJJr5 c L t j |j d S )N packed-refs)osr( joinr1 )clsr' s r3 _get_packed_refs_pathz'SymbolicReference._get_packed_refs_pathk s w||DO];;;r5 c # K t | | dd 5 }|D ]}| }|s| d r,| d rd|vrt d|z Z|d d k rgt t t t f t | d
d V d d d d S # 1 swxY w Y d S # t $ r Y d S w xY w)
zReturns 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 iteratertUTF-8encoding#z# pack-refs with:peeledz-PackingType of packed-Refs not understood: %rr ^ r N) openrZ strip
startswith TypeErrorr r r@ tuplesplitOSError)rY r' fplines r3 _iter_packed_refsz#SymbolicReference._iter_packed_refso s c//55tgNNN
KRT K KD ::<?? dHTXDXDX"+,[^b,b"c"c c
Aw#~~ uS#Xdjja6H6H0I0IJJJJJJ1K
K
K
K
K
K
K
K
K
K
K
K
K
K
K
K
K
K
K6 44 s5 %C9 B5C, C9 ,C00C9 3C04C9 9
DDref_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)rY r' rn hexshas r3 dereference_recursivez'SymbolicReference.dereference_recursive s1 " 0 0x @ @ FH!
r5 c d}t || } t t j |t | dd 5 }| }ddd n # 1 swxY w Y | }t | dk sJ n6# t $ r) | | D ]\ }}||k r ||f} Y nw xY w|t d|z |d dk r
d|d fS |j
|d r
|d dfS t d |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^ r z Reference at %r does not existzref:r z-Failed to parse reference information from %r)r4 rd rW r( rX r@ readrstripri lenrj rm
ValueErrorre_hexsha_onlymatch) rY r' rn tokensrepodirrk valueshar( s r3 _get_ref_info_helperz&SymbolicReference._get_ref_info_helper s ;?4** bgll7CMM::D7SSS
+WY ((**
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ [[]]Fv;;!##### ! 2 24 8 8
T8## d > = HII I !9 &)$ $ $ $VAY / / %1It$ $H8STTTs5 =B9 'B8 B9 BB9 B ,B9 90C,+C,c . | || S )rt )r )rY r' rn s r3 rp z SymbolicReference._get_ref_info s
''h777r5 c t j | j t | | 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' r rr r( rA s r3 _get_objectz SymbolicReference._get_object s9 "49j9S9STXT]_c_h9i9i.j.jkkkr5 r c | }|j dk r|j }|j t j k rt 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??QF
G
= 2V ;<< <
''' s -B
B6 B11B6r c t |t r|j }d} | j }n# t $ r Y nw xY w|r| || S | || S )a8 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 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 r3 r z SymbolicReference.set_object
s f / 0 0 #]F *KK D 6%%ff55 5 ""$$//???s (
55z Query 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 )rp r' r( rg from_path)r< r~ target_ref_paths r3 r z SymbolicReference._get_reference/ s\ $ 1 1$)TY G G _ "X\X\X\^a^a bcc c~~di 999r5 refc d}d}t |t r d|j z }nt |t r
|}|j }nyt |t
rR | j |dz }|j }n># t t f$ r}t d|z |d}~ww xY wt d|z |.| j r'|j t j k rt d|z d}|* | j j }n # t $ r t j }Y nw xY w| j }t' |d t) | }| dd
} d}
| | d d z | d}
|
s| n # |
s| w w xY w|| || | 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 %rr5 T)is_file)writestreamzutf-8
)r r% r( r rq r@ r' r r
r rx _points_to_commits_onlyr r rg r binsha NULL_BIN_SHArT r
r rd r encoderollback
log_append) r< r r write_valuer r oldbinshafpathlfdfdoks r3 r z SymbolicReference.set_reference8 s) , c, - -
=#ch.KK
V
$
$ =C *KK
S
!
! =
Ri))#+66 !j w'
R
R
R !Cc!IJJPQQ
R 5 ;<< < ?t ;?FK@W@W 4s :;; ;
0 K .
0
0
0 " /
0
t4444uoo
XXDX
.
.
HH[''0058 9 9 9 JJLLLB
OOIv . . . s7 $A? ?B(B##B(2 C? ?DD AF4 4G
r referencez!Returns the Reference we point toc F | j dS # t t f$ r Y dS w xY w)z
:return:
True if the reference is valid, hence it can be read and points to
a valid object or reference.TF)r rj rx rA s r3 is_validzSymbolicReference.is_valid s>
KK 4 $ 55 s c 8 | j dS # t $ r Y dS w xY w)z
:return:
True if we are a detached reference, hence we point to a specific commit
instead to another referenceFT)r rg rA s r3 r z SymbolicReference.is_detached s5 HH5 44 s
r c N t j t j | 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( rA s r3 logzSymbolicReference.log s D 1 1222r5 r message newbinshar! c | j j }n)# t $ r | j }Y nw xY w| | j j }|d}t
j |t
j | ||| S )aB 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: added RefLogEntry instanceNr8 ) r committerrx r'
config_readerr r append_entryr( )r< r r r committer_or_readers r3 r z SymbolicReference.log_append s z+SymbolicReference.delete.. s. %P%Pddkk&&9&9%P%P%P%P%P%Pr5 )r rW r( rX r1 existsremoverZ rd decoder partitionre rf append
writelinesrj r isfile)rY r' r( r abs_pathpack_file_pathreader new_lines made_changedropped_last_line
line_bytesrl _line_refr reflog_paths r3 deletezSymbolicReference.delete s ((..
7<< ??
7>>( # # & Ih ! 6 6t < >#3#3
!OOC 0 0 %MX4M4M 1 5N5F 5NOS_bOcOc 5N & , ,T 2 2 205 - $ '+ ,0))%1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 12 Q nd33 Qr
%P%Pi%P%P%PPPPQ Q Q Q Q Q Q Q Q Q Q Q Q Q Q
k##dM":":;;
7>>+ & & # Ik " " " " " # #s[ F B#E: F E
F
E
F # F F FF FF
F('F(rY resolveforcec t || }| | }t j || } |}
|r"| t
| }
|st j | rt
|
} t |
t rt
|
j } |sd| z } t | d 5 } | t }
ddd n # 1 swxY w Y |
| k rt d|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 )r4 r rW r( rX r r@ r r r% rd ru r r re rj r )rY r' r( r r r r r0 r abs_ref_pathtarget target_datar
existing_datar s r3 _createzSymbolicReference._create s 4&&((..
w||G];; 4^^C NN33F 55 f++K&"344
/ !&+ . .
4 % 3 lD))
AR " 0 0 8 8 > > @ @
A
A
A
A
A
A
A
A
A
A
A
A
A
A
A ++ g$}}mmm[[B c$
&& &&)))
s ?D''D+.D+r+ kwargsc @ | ||| j ||| S )a Create 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)rY r' r( r r r r s r3 createzSymbolicReference.createA s% L {{4s'A9eU[\\\r5 new_pathc | | }| j |k r| S t j t | j | | }t j t | j | j | j }t j | r|st |d 5 }| }ddd n # 1 swxY w Y t |d 5 }| }ddd n # 1 swxY w Y ||k rt d|z t j | t j | } t j
| st j | t j || || _ | S )a7 Rename 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 Nz File at path %r already exists)r r( rW rX r4 r' r rd ru re rj r dirnameisdirmakedirsrename)
r< r r new_abs_path cur_abs_pathfd1f1fd2f2dnames
r3 r zSymbolicReference.renamei s $$X.. 9 Kw||HTY$A$A8LL w||HTY $B$BDINN
7>>, ' ' $
S,-- , ))++B, , , , , , , , , , , , , , ,,-- , ))++B, , , , , , , , , , , , , , ,88!"B\"QRRR
Il # # # --w}}U## K , --- s$ 'C77C;>C;'EE E common_pathc # K || j }t }t j t |j | D ]\ }}}d| t j vrd |D }|rdg|dd < |D ]d}|dk r t t || } |
| t |j dz d e| | D ]<\ }
} |
t | r|
| =t | D ]+} | || V # t" $ r Y (w xY wd S )Nrefsc g | ]
}|d k | S )r rM )r ds r3
z1SymbolicReference._iter_items.. s :::a6kk1kkkr5 r rV r r8 )r setrW walkr r1 ri sepr r addreplacerm rf r@ sortedr rx )
rY r' r
rela_pathsrootdirsfilesrefs_idfr _sha rela_pathr( s
r3 _iter_itemsz SymbolicReference._iter_items s 2KUU
"$)9$/;)W)W!X!X b b D$TZZ / ///::d::: ( &xDH
b
b
%% / $0B0BCCx / /0DT_0U0UX[0[]_ ` `aaaa
b # 4 4T : : * *OD)##C $4$455
*y)))
:&& D
mmD$//////
s
E##
E0/E0argsc 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 TagReferencec 3 H K | ] }|j t k s|j |V d S r; )rD r% r )r rs r3 r z/SymbolicReference.iter_items.. s8 wwaPaAaAaijivAaAaAaAaAawwr5 )r )rY r' r r r s r3
iter_itemsz SymbolicReference.iter_items s' 0 xw3??4==wwwwr5 c |st d|z ddlm}m}m}m}m} |||||t fD ]H} ||| } | j t k r| j rt d | c S # t $ r Y Ew xY wt d|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 pathz Cannot create Reference from %rr )r+ r r r r z"SymbolRef was detached, we drop itz8Could not find reference type suitable to handle path %r)
rx r8 r+ r r r r r% rD r )
rY r' r( r+ r r r r ref_typeinstances
r3 r zSymbolicReference.from_path s G > EFF F KJJJJJJJJJJJJJ
H
#8D$//%):::x?S:$%IJJJ#OOO
SVZZ[[[s 3A))
A65A6c ` t | j | j dz S )zB:return: True if this symbolic reference points to a remote branchr )r@ r( rf _remote_common_path_defaultrA s r3 is_remotezSymbolicReference.is_remote s& 49~~(()IC)OPPPr5 )F)r) r r; )r) r% )r) r )r+ NF)?rE
__module__ __qualname____doc__ __slots__r r r r _id_attribute_r boolr= r@ rB rF r rK rN intrQ propertyr2 rT classmethodrZ r r rm r rr r rp r r r r r r r r r __annotations__r r r r r bytesr r r r r r$ r r r r r r
r r rM r5 r3 r% r% : sj ; ; !I " " "0 N V 8 F# F F F FF t #F #t # # # # # c X K K K K XK < %:&U uS$Y tSy!11 2&U &U &U [&UP 8 854 3H 8USXY\^bYbScejkoqtkteuSuMv 8 8 8 [8 lZ l l l l
$ $( f 1367 c4i
H $( @ @j"5s:; @ c4i @
@ @ @ @> Xk:3R
S
S
SF
Xk:3b
c
c
cF: : : : $(G G
: 2C7
8G c4i G
G G G GT KLLLL <_```I
C
$
T X 3 3 3 3 )- j jj sDy!j % j
j j j j:9s 9} 9 9 9 9 h0C&C D [ 7#& 7# 7#T 7# 7# 7# [7#t $(( (
,
(( ( (
,c12 (
( c4i (
( ( ( [(T
6<#'
%] %]
,
%]%] %] ,c12 %]
c4i %]
%] %]
%] %] %] [%]N+ +x + +AT + + + +Z TX$ $
,
$'-$*x x
x
,
x x x [x2 "\tL) "\ "\x "\L "\ "\ "\ ["\HQ4 Q Q Q Q Q Qr5 )0 git.typesr rW
git.compatr git.objectsr git.objects.commitr git.utilr r r r
r r gitdb.excr
r r r typingr r r r r r r r r r git.repor git.refsr r r r r!
git.configr" r# r$ __all__r4 r r% rM r5 r3 r* si % % % % % % ) ( ( ( ( ( ( (
+ * * * * * * * ) GGGGGGGGGGGG ******(((((( w~-@AAA
6 x~!6 8 E Q E Q E Q E Q E Q E Q E Q E Q E Q E Qr5