fromgit.cmdimporthandle_process_output,Git

fromgit.compatimport (defenc,force_text,is_win)

fromgit.excimportGitCommandError

fromgit.utilimport (

LazyMixin,

Iterable,

IterableList,

RemoteProgress,

)

fromgit.utilimport (

join_path,

)

importos.pathasosp

from .configimport (

SectionConstraint,

cp,

)

from .refsimport (

Head,

Reference,

RemoteReference,

SymbolicReference,

)

log=logging.getLogger('git.remote')

log.addHandler(logging.NullHandler())

__all__= ('RemoteProgress','PushInfo','FetchInfo','Remote')

defadd_progress(kwargs,git,progress):

ifprogressisnotNone:

v=git.version_info[:2]

ifv>= (1,7):

kwargs['progress']=True

defto_progress_instance(progress):

ifcallable(progress):

returnCallableRemoteProgress(progress)

elifprogressisNone:

returnRemoteProgress()

else:

classPushInfo(object):

__slots__= ('local_ref','remote_ref_string','flags','_old_commit_sha','_remote','summary')

NEW_TAG,NEW_HEAD,NO_MATCH,REJECTED,REMOTE_REJECTED,REMOTE_FAILURE,DELETED, \

FORCED_UPDATE,FAST_FORWARD,UP_TO_DATE,ERROR= [1<<xforxinrange(11)]

_flag_map= {'X':NO_MATCH,

'-':DELETED,

'*':0,

'+':FORCED_UPDATE,

' ':FAST_FORWARD,

'=':UP_TO_DATE,

'!':ERROR}

def__init__(self,flags,local_ref,remote_ref_string,remote,old_commit=None,

summary=''):

self.flags=flags

self.local_ref=local_ref

self.remote_ref_string=remote_ref_string

self._remote=remote

self._old_commit_sha=old_commit

self.summary=summary

defold_commit(self):

returnself._old_commit_shaandself._remote.repo.commit(self._old_commit_sha)orNone

defremote_ref(self):

ifself.remote_ref_string.startswith("refs/tags"):

returnTagReference(self._remote.repo,self.remote_ref_string)

elifself.remote_ref_string.startswith("refs/heads"):

remote_ref=Reference(self._remote.repo,self.remote_ref_string)

returnRemoteReference(self._remote.repo,"refs/remotes/%s/%s"% (str(self._remote),remote_ref.name))

else:

raiseValueError("Could not handle remote ref: %r"%self.remote_ref_string)

def_from_line(cls,remote,line):

control_character,from_to,summary=line.split('\t',3)

try:

flags|=cls._flag_map[control_character]

exceptKeyError:

raiseValueError("Control character %r unknown as parsed from line %r"% (control_character,line))

from_ref_string,to_ref_string=from_to.split(':')

ifflags&cls.DELETED:

else:

from_ref=Reference.from_path(remote.repo,from_ref_string)

ifsummary.startswith('['):

if"[rejected]"insummary:

flags|=cls.REJECTED

elif"[remote rejected]"insummary:

flags|=cls.REMOTE_REJECTED

elif"[remote failure]"insummary:

flags|=cls.REMOTE_FAILURE

elif"[no match]"insummary:

flags|=cls.ERROR

elif"[new tag]"insummary:

flags|=cls.NEW_TAG

elif"[new branch]"insummary:

flags|=cls.NEW_HEAD

else:

ifcontrol_character==" ":

old_sha,new_sha=summary.split(' ')[0].split(split_token)# @UnusedVariable

returnPushInfo(flags,from_ref,to_ref_string,remote,old_commit,summary)

classFetchInfo(object):

__slots__= ('ref','old_commit','flags','note','remote_ref_path')

NEW_TAG,NEW_HEAD,HEAD_UPTODATE,TAG_UPDATE,REJECTED,FORCED_UPDATE, \

FAST_FORWARD,ERROR= [1<<xforxinrange(8)]

_re_fetch_result=re.compile(r'^\s*(.) (\[?[\w\s\.$@]+\]?)\s+(.+) -> ([^\s]+)( \(.*\)?$)?')

_flag_map= {

'!':ERROR,

'+':FORCED_UPDATE,

'*':0,

'=':HEAD_UPTODATE,

' ':FAST_FORWARD,

'-':TAG_UPDATE,

}

defrefresh(cls):

try:

delcls._flag_map["t"]

exceptKeyError:

try:

delcls._flag_map["-"]

exceptKeyError:

ifGit().version_info[:2]>= (2,10):

cls._flag_map["t"]=cls.TAG_UPDATE

else:

cls._flag_map["-"]=cls.TAG_UPDATE

def__init__(self,ref,flags,note='',old_commit=None,remote_ref_path=None):

self.ref=ref

self.flags=flags

self.note=note

self.old_commit=old_commit

self.remote_ref_path=remote_ref_path

def__str__(self):

returnself.name

defname(self):

returnself.ref.name

defcommit(self):

returnself.ref.commit

def_from_line(cls,repo,line,fetch_line):

match=cls._re_fetch_result.match(line)

ifmatchisNone:

raiseValueError("Failed to parse line: %r"%line)

control_character,operation,local_remote_ref,remote_local_ref,note=match.groups()

try:

new_hex_sha,fetch_operation,fetch_note=fetch_line.split("\t")# @UnusedVariable

ref_type_name,fetch_note=fetch_note.split(' ',1)

exceptValueError:# unpack error

raiseValueError("Failed to parse FETCH_HEAD line: %r"%fetch_line)

try:

flags|=cls._flag_map[control_character]

exceptKeyError:

raiseValueError("Control character %r unknown as parsed from line %r"% (control_character,line))

if'rejected'inoperation:

flags|=cls.REJECTED

if'new tag'inoperation:

flags|=cls.NEW_TAG

if'tag update'inoperation:

flags|=cls.TAG_UPDATE

if'new branch'inoperation:

flags|=cls.NEW_HEAD

if'...'inoperationor'..'inoperation:

ifcontrol_character==' ':

split_token=split_token[:-1]

old_commit=repo.rev_parse(operation.split(split_token)[0])

ifremote_local_ref=="FETCH_HEAD":

elifref_type_name=="tag"oris_tag_operation:

elifref_type_namein ("remote-tracking","branch"):

elif'/'inref_type_name:

else:

raiseTypeError("Cannot handle reference type: %r"%ref_type_name)

ifref_typeisSymbolicReference:

remote_local_ref=ref_type(repo,"FETCH_HEAD")

else:

remote_local_ref=remote_local_ref.strip()

ifremote_local_ref.startswith(Reference._common_path_default+"/"):

ifref_typeisnotTagReferenceandnot \

remote_local_ref.startswith(RemoteReference._common_path_default+"/"):

elifref_typeisTagReferenceand'tags/'inremote_local_ref:

ref_path=join_path(RemoteReference._common_path_default,remote_local_ref)

else:

ref_path=join_path(ref_type._common_path_default,remote_local_ref)

remote_local_ref=ref_type(repo,ref_path,check_path=False)

note= (noteandnote.strip())or''

returncls(remote_local_ref,flags,note,old_commit,local_remote_ref)

classRemote(LazyMixin,Iterable):

__slots__= ("repo","name","_config_reader")

def__init__(self,repo,name):

self.repo=repo

self.name=name

ifis_win:

dir(self)

def__getattr__(self,attr):

ifattr=="_config_reader":

returnsuper(Remote,self).__getattr__(attr)

try:

returnself._config_reader.get(attr)

exceptcp.NoOptionError:

returnsuper(Remote,self).__getattr__(attr)

def_config_section_name(self):

return'remote "%s"'%self.name

def_set_cache_(self,attr):

ifattr=="_config_reader":

self._config_reader=SectionConstraint(self.repo.config_reader("repository"),self._config_section_name())

else:

super(Remote,self)._set_cache_(attr)

def__str__(self):

returnself.name

def__repr__(self):

return'<git.%s "%s">'% (self.__class__.__name__,self.name)

def__eq__(self,other):

returnself.name==other.name

def__ne__(self,other):

returnnot (self==other)

def__hash__(self):

returnhash(self.name)

defexists(self):

try:

self.config_reader.get('url')

exceptcp.NoOptionError:

exceptcp.NoSectionError:

defiter_items(cls,repo):

forsectioninrepo.config_reader("repository").sections():

ifnotsection.startswith('remote '):

lbound=section.find('"')

rbound=section.rfind('"')

iflbound==-1orrbound==-1:

raiseValueError("Remote-Section has invalid format: %r"%section)

yieldRemote(repo,section[lbound+1:rbound])

defset_url(self,new_url,old_url=None,**kwargs):

kwargs['insert_kwargs_after']=scmd

ifold_url:

self.repo.git.remote(scmd,self.name,new_url,old_url,**kwargs)

else:

self.repo.git.remote(scmd,self.name,new_url,**kwargs)

defadd_url(self,url,**kwargs):

returnself.set_url(url,add=True)

defdelete_url(self,url,**kwargs):

returnself.set_url(url,delete=True)

defurls(self):

try:

remote_details=self.repo.git.remote("get-url","--all",self.name)

forlineinremote_details.split('\n'):

exceptGitCommandErrorasex:

if'Unknown subcommand: get-url'instr(ex):

try:

remote_details=self.repo.git.remote("show",self.name)

forlineinremote_details.split('\n'):

if' Push URL:'inline:

yieldline.split(': ')[-1]

exceptGitCommandErrorasex:

ifany(msginstr(ex)formsgin ['correct access rights','cannot run ssh']):

remote_details=self.repo.git.config('--get-all','remote.%s.url'%self.name)

forlineinremote_details.split('\n'):

else:

else:

defrefs(self):

out_refs=IterableList(RemoteReference._id_attribute_,"%s/"%self.name)

out_refs.extend(RemoteReference.list_items(self.repo,remote=self.name))

defstale_refs(self):

out_refs=IterableList(RemoteReference._id_attribute_,"%s/"%self.name)

forlineinself.repo.git.remote("prune","--dry-run",self).splitlines()[2:]:

ifnotline.startswith(token):

raiseValueError("Could not parse git-remote prune result: %r"%line)

ref_name=line.replace(token,"")

ifref_name.startswith(Reference._common_path_default+'/'):

out_refs.append(SymbolicReference.from_path(self.repo,ref_name))

else:

fqhn="%s/%s"% (RemoteReference._common_path_default,ref_name)

out_refs.append(RemoteReference(self.repo,fqhn))

defcreate(cls,repo,name,url,**kwargs):

kwargs['insert_kwargs_after']=scmd

repo.git.remote(scmd,name,Git.polish_url(url),**kwargs)

returncls(repo,name)

defremove(cls,repo,name):

repo.git.remote("rm",name)

ifisinstance(name,cls):

name._clear_cache()

defrename(self,new_name):

ifself.name==new_name:

self.repo.git.remote("rename",self.name,new_name)

self.name=new_name

self._clear_cache()

defupdate(self,**kwargs):

kwargs['insert_kwargs_after']=scmd

self.repo.git.remote(scmd,self.name,**kwargs)

def_get_fetch_info_from_stderr(self,proc,progress):

progress=to_progress_instance(progress)

output=IterableList('name')

fetch_info_lines= []

cmds=set(FetchInfo._flag_map.keys())

progress_handler=progress.new_message_handler()

handle_process_output(proc,None,progress_handler,finalizer=None,decode_streams=False)

stderr_text=progress.error_linesand'\n'.join(progress.error_lines)or''

proc.wait(stderr=stderr_text)

ifstderr_text:

log.warning("Error lines received while fetching: %s",stderr_text)

forlineinprogress.other_lines:

line=force_text(line)

forcmdincmds:

iflen(line)>1andline[0]==' 'andline[1]==cmd:

fetch_info_lines.append(line)

withopen(osp.join(self.repo.common_dir,'FETCH_HEAD'),'rb')asfp:

fetch_head_info= [l.decode(defenc)forlinfp.readlines()]

l_fil=len(fetch_info_lines)

l_fhi=len(fetch_head_info)

ifl_fil!=l_fhi:

msg%= (l_fil,l_fhi)

log.debug(msg)

log.debug("info lines: "+str(fetch_info_lines))

log.debug("head info : "+str(fetch_head_info))

ifl_fil<l_fhi:

fetch_head_info=fetch_head_info[:l_fil]

else:

fetch_info_lines=fetch_info_lines[:l_fhi]

output.extend(FetchInfo._from_line(self.repo,err_line,fetch_line)

forerr_line,fetch_lineinzip(fetch_info_lines,fetch_head_info))

def_get_push_info(self,proc,progress):

progress=to_progress_instance(progress)

progress_handler=progress.new_message_handler()

output=IterableList('name')

defstdout_handler(line):

try:

output.append(PushInfo._from_line(self,line))

exceptValueError:

handle_process_output(proc,stdout_handler,progress_handler,finalizer=None,decode_streams=False)

stderr_text=progress.error_linesand'\n'.join(progress.error_lines)or''

try:

proc.wait(stderr=stderr_text)

exceptException:

ifnotoutput:

elifstderr_text:

log.warning("Error lines received while fetching: %s",stderr_text)

def_assert_refspec(self):

config=self.config_reader

try:

ifconfig.get_value('fetch',default=unset)isunset:

raiseAssertionError(msg% (self.name,self.name))

finally:

config.release()

deffetch(self,refspec=None,progress=None,**kwargs):

ifrefspecisNone:

self._assert_refspec()

kwargs=add_progress(kwargs,self.repo.git,progress)

ifisinstance(refspec,list):

else:

args= [refspec]

proc=self.repo.git.fetch(self,*args,as_process=True,with_stdout=False,

universal_newlines=True,v=True,**kwargs)

res=self._get_fetch_info_from_stderr(proc,progress)

ifhasattr(self.repo.odb,'update_cache'):

self.repo.odb.update_cache()

defpull(self,refspec=None,progress=None,**kwargs):

ifrefspecisNone:

self._assert_refspec()

kwargs=add_progress(kwargs,self.repo.git,progress)

proc=self.repo.git.pull(self,refspec,with_stdout=False,as_process=True,

universal_newlines=True,v=True,**kwargs)

res=self._get_fetch_info_from_stderr(proc,progress)

ifhasattr(self.repo.odb,'update_cache'):

self.repo.odb.update_cache()

defpush(self,refspec=None,progress=None,**kwargs):

kwargs=add_progress(kwargs,self.repo.git,progress)

proc=self.repo.git.push(self,refspec,porcelain=True,as_process=True,

universal_newlines=True,**kwargs)

returnself._get_push_info(proc,progress)

defconfig_reader(self):

returnself._config_reader

def_clear_cache(self):

try:

del(self._config_reader)

exceptAttributeError:

defconfig_writer(self):

writer=self.repo.config_writer()

self._clear_cache()

returnSectionConstraint(writer,self._config_section_name())