def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test', committer=b'test')
# Setup target repo
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
target_repo = porcelain.clone(self.repo.path, target=target_path,
errstream=errstream)
target_repo.close()
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b'test2',
author=b'test2', committer=b'test2')
# Pull changes into the cloned repo
porcelain.pull(target_path, self.repo.path, b'refs/heads/master',
outstream=outstream, errstream=errstream)
# Check the target repo for pushed changes
with closing(Repo(target_path)) as r:
self.assertEqual(r[b'HEAD'].id, self.repo[b'HEAD'].id)
def setUp(self):
super(PullTests, self).setUp()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test <email>',
committer=b'test <email>')
# Setup target repo
self.target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.target_path)
target_repo = porcelain.clone(self.repo.path, target=self.target_path,
errstream=BytesIO())
target_repo.close()
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(repo=self.repo.path, message=b'test2',
author=b'test2 <email>',
committer=b'test2 <email>')
self.assertTrue(b'refs/heads/master' in self.repo.refs)
self.assertTrue(b'refs/heads/master' in target_repo.refs)
def test_hard_commit(self):
with open(os.path.join(self.repo.path, "foo"), "w") as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=["foo"])
sha = porcelain.commit(
self.repo.path,
message=b"Some message",
committer=b"Jane <*****@*****.**>",
author=b"John <*****@*****.**>",
)
with open(os.path.join(self.repo.path, "foo"), "wb") as f:
f.write(b"BAZ")
porcelain.add(self.repo.path, paths=["foo"])
porcelain.commit(
self.repo.path,
message=b"Some other message",
committer=b"Jane <*****@*****.**>",
author=b"John <*****@*****.**>",
)
porcelain.reset(self.repo, "hard", sha)
index = self.repo.open_index()
changes = list(tree_changes(self.repo, index.commit(self.repo.object_store), self.repo[sha].tree))
self.assertEqual([], changes)
def test_hard_head(self):
f = open(os.path.join(self.repo.path, 'foo'), 'w')
try:
f.write("BAR")
finally:
f.close()
porcelain.add(self.repo.path, paths=["foo"])
porcelain.commit(self.repo.path, message="Some message",
committer="Jane <*****@*****.**>",
author="John <*****@*****.**>")
f = open(os.path.join(self.repo.path, 'foo'), 'w')
try:
f.write("OOH")
finally:
f.close()
porcelain.reset(self.repo, "hard", "HEAD")
index = self.repo.open_index()
changes = list(tree_changes(self.repo,
index.commit(self.repo.object_store),
self.repo['HEAD'].tree))
self.assertEqual([], changes)
def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b"test", author=b"test", committer=b"test")
# Setup target repo
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
target_repo = porcelain.clone(self.repo.path, target=target_path, errstream=errstream)
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b"test2", author=b"test2", committer=b"test2")
self.assertFalse(self.repo[b"HEAD"].id in target_repo)
target_repo.close()
# Fetch changes into the cloned repo
porcelain.fetch(target_path, self.repo.path, outstream=outstream, errstream=errstream)
# Check the target repo for pushed changes
with closing(Repo(target_path)) as r:
self.assertTrue(self.repo[b"HEAD"].id in r)
def test_delete(self):
"""Basic test of porcelain push, removing a branch.
"""
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(repo=self.repo.path, message=b'init',
author=b'', committer=b'')
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.clone(self.repo.path, target=clone_path,
errstream=errstream)
target_repo.close()
# Setup a non-checked out branch in the remote
refs_path = b"refs/heads/foo"
new_id = self.repo[b'HEAD'].id
self.assertNotEqual(new_id, ZERO_SHA)
self.repo.refs[refs_path] = new_id
# Push to the remote
porcelain.push(clone_path, self.repo.path, b":" + refs_path, outstream=outstream,
errstream=errstream)
self.assertEqual({
b'HEAD': new_id,
b'refs/heads/master': new_id,
}, self.repo.get_refs())
def rename_file(self, old_path, new_path):
# paths must not be unicode. :(
old_files = [old_path]
new_files = [new_path]
if self.save_script and ".ipynb" in old_path:
old_files.append(old_files[0].replace('.ipynb', '.py'))
new_files.append(new_files[0].replace('.ipynb', '.py'))
renamed = super(GitNotebookManager, self).rename_file(old_path, new_path)
isFolder = os.path.splitext(old_path)[-1] == ""
if any(old_path.endswith(ext) for ext in self._tracked_ext) or isFolder:
if isFolder:
subprocess.call(["git", "rm", "-r", str(old_path)], shell=False)
subprocess.call(["git", "add", str(new_path)], shell=False)
self._repo = None
self._check_repo()
else:
git.rm(self._repo, [str(_) for _ in old_files])
git.add(self._repo, [str(_) for _ in new_files])
self.log.debug("Notebook renamed from '%s' to '%s'" % (old_files[0],
new_files[0]))
git.commit(self._repo, "IPython notebook rename\n\n"
"Automated commit from IPython via ipylogue",
committer=self.committer_fullname)
# git.push(self._repo, self._repo.get_config()[('remote', 'origin')]["url"], "refs/heads/master")
return renamed
def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test', committer=b'test')
# Setup target repo
target_path = tempfile.mkdtemp()
target_repo = porcelain.clone(self.repo.path, target=target_path,
errstream=errstream)
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b'test2',
author=b'test2', committer=b'test2')
self.assertFalse(self.repo[b'HEAD'].id in target_repo)
# Fetch changes into the cloned repo
porcelain.fetch(target_path, self.repo.path, outstream=outstream,
errstream=errstream)
# Check the target repo for pushed changes
r = Repo(target_path)
self.assertTrue(self.repo[b'HEAD'].id in r)
def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message='test',
author='test', committer='test')
# Setup target repo
target_path = tempfile.mkdtemp()
porcelain.clone(self.repo.path, target=target_path, outstream=outstream)
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message='test2',
author='test2', committer='test2')
# Pull changes into the cloned repo
porcelain.pull(target_path, self.repo.path, 'refs/heads/master',
outstream=outstream, errstream=errstream)
# Check the target repo for pushed changes
r = Repo(target_path)
self.assertEqual(r['HEAD'].id, self.repo['HEAD'].id)
def test_empty(self):
porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'', committer=b'')
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
self.assertEqual(f.getvalue(), "")
def test_status(self):
"""Integration test for `status` functionality."""
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, 'foo')
with open(fullpath, 'w') as f:
f.write('origstuff')
porcelain.add(repo=self.repo.path, paths=['foo'])
porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'', committer=b'')
# modify access and modify time of path
os.utime(fullpath, (0, 0))
with open(fullpath, 'wb') as f:
f.write(b'stuff')
# Make a dummy file and stage it
filename_add = 'bar'
fullpath = os.path.join(self.repo.path, filename_add)
with open(fullpath, 'w') as f:
f.write('stuff')
porcelain.add(repo=self.repo.path, paths=filename_add)
results = porcelain.status(self.repo)
self.assertEqual(results.staged['add'][0], filename_add.encode('ascii'))
self.assertEqual(results.unstaged, [b'foo'])
def test_add_default_paths(self):
# create a file for initial commit
fullpath = os.path.join(self.repo.path, 'blah')
with open(fullpath, 'w') as f:
f.write("\n")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test <email>', committer=b'test <email>')
# Add a second test file and a file in a directory
with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
f.write("\n")
os.mkdir(os.path.join(self.repo.path, 'adir'))
with open(os.path.join(self.repo.path, 'adir', 'afile'), 'w') as f:
f.write("\n")
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
porcelain.add(self.repo.path)
finally:
os.chdir(cwd)
# Check that foo was added and nothing in .git was modified
index = self.repo.open_index()
self.assertEqual(sorted(index), [b'adir/afile', b'blah', b'foo'])
def test_status(self):
"""Integration test for `status` functionality."""
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("origstuff")
porcelain.add(repo=self.repo.path, paths=["foo"])
porcelain.commit(repo=self.repo.path, message=b"test status", author=b"", committer=b"")
# modify access and modify time of path
os.utime(fullpath, (0, 0))
with open(fullpath, "wb") as f:
f.write(b"stuff")
# Make a dummy file and stage it
filename_add = "bar"
fullpath = os.path.join(self.repo.path, filename_add)
with open(fullpath, "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=filename_add)
results = porcelain.status(self.repo)
self.assertEqual(results.staged["add"][0], filename_add.encode("ascii"))
self.assertEqual(results.unstaged, [b"foo"])
def test_simple(self):
"""
Basic test of porcelain push where self.repo is the remote. First
clone the remote, commit a file to the clone, then push the changes
back to the remote.
"""
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(repo=self.repo.path, message=b'init',
author=b'author <email>',
committer=b'committer <email>')
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.clone(self.repo.path, target=clone_path,
errstream=errstream)
try:
self.assertEqual(target_repo[b'HEAD'], self.repo[b'HEAD'])
finally:
target_repo.close()
# create a second file to be pushed back to origin
handle, fullpath = tempfile.mkstemp(dir=clone_path)
os.close(handle)
porcelain.add(repo=clone_path, paths=[fullpath])
porcelain.commit(repo=clone_path, message=b'push',
author=b'author <email>',
committer=b'committer <email>')
# Setup a non-checked out branch in the remote
refs_path = b"refs/heads/foo"
new_id = self.repo[b'HEAD'].id
self.assertNotEqual(new_id, ZERO_SHA)
self.repo.refs[refs_path] = new_id
# Push to the remote
porcelain.push(clone_path, self.repo.path, b"HEAD:" + refs_path,
outstream=outstream, errstream=errstream)
# Check that the target and source
with Repo(clone_path) as r_clone:
self.assertEqual({
b'HEAD': new_id,
b'refs/heads/foo': r_clone[b'HEAD'].id,
b'refs/heads/master': new_id,
}, self.repo.get_refs())
self.assertEqual(r_clone[b'HEAD'].id, self.repo[refs_path].id)
# Get the change in the target repo corresponding to the add
# this will be in the foo branch.
change = list(tree_changes(self.repo, self.repo[b'HEAD'].tree,
self.repo[b'refs/heads/foo'].tree))[0]
self.assertEqual(os.path.basename(fullpath),
change.new.path.decode('ascii'))
def git_commit(args):
if len(args) == 3:
try:
repo = _get_repo()
#print repo.commit(name=args[1],email=args[2],message=args[0])
author = "{0} <{1}>".format(args[1], args[2])
print porcelain.commit(repo.repo, args[0], author, author )
except:
print 'Error: {0}'.format(sys.exc_value)
else:
print command_help['commit']
def test_simple(self):
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("origstuff")
porcelain.add(repo=self.repo.path, paths=["foo"])
porcelain.commit(repo=self.repo.path, message=b"test status", author=b"", committer=b"")
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
self.assertEqual(f.getvalue(), "100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n")
def commit(self,sender):
if list(itertools.chain(*porcelain.status(self.g.path).staged.itervalues())):
self.g=self._get_repo()
user=self.view['user'].text
email=self.view['email'].text
message=self.view['message'].text
author = "{0} <{1}>".format(user, email)
porcelain.commit(self.g.path,message,author,author)
console.hud_alert('committed')
self.view['message'].text=''
self.refresh()
else:
console.hud_alert('nothing to commit!',icon='error')
def delete(self, path):
super(GitNotebookManager, self).delete(path)
isFolder = os.path.splitext(path)[-1] == ""
if any(path.endswith(ext) for ext in self._tracked_ext) or isFolder:
if isFolder:
subprocess.call(["git", "rm", "-r", str(path)[1:]], shell=False)
self._repo = None
self._check_repo()
else:
git.rm(self._repo, [str(path)[1:]])
self.log.debug("Notebook {0} deleted".format(path))
git.commit(self._repo, "IPython notebook delete\n\n"
"Automated commit from IPython via ipylogue",
committer=self.committer_fullname)
def test_simple(self):
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, 'foo')
with open(fullpath, 'w') as f:
f.write('origstuff')
porcelain.add(repo=self.repo.path, paths=['foo'])
porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'', committer=b'')
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
self.assertEqual(
f.getvalue(),
'100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n')
def test_simple(self):
"""
Basic test of porcelain push where self.repo is the remote. First
clone the remote, commit a file to the clone, then push the changes
back to the remote.
"""
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(repo=self.repo.path,
message='init',
author='',
committer='')
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
porcelain.clone(self.repo.path, target=clone_path, outstream=outstream)
# create a second file to be pushed back to origin
handle, fullpath = tempfile.mkstemp(dir=clone_path)
porcelain.add(repo=clone_path, paths=[os.path.basename(fullpath)])
porcelain.commit(repo=clone_path,
message='push',
author='',
committer='')
# Setup a non-checked out branch in the remote
refs_path = os.path.join('refs', 'heads', 'foo')
self.repo[refs_path] = self.repo['HEAD']
# Push to the remote
porcelain.push(clone_path,
self.repo.path,
refs_path,
outstream=outstream,
errstream=errstream)
# Check that the target and source
r_clone = Repo(clone_path)
# Get the change in the target repo corresponding to the add
# this will be in the foo branch.
change = list(
tree_changes(self.repo, self.repo['HEAD'].tree,
self.repo['refs/heads/foo'].tree))[0]
self.assertEqual(r_clone['HEAD'].id, self.repo[refs_path].id)
self.assertEqual(os.path.basename(fullpath), change.new.path)
def _rename(self, name=None, new_name=None):
if not name:
self.q.put([Action.ask_input, _("Rename which password?"), "", "rename"])
elif not new_name:
self.q.put([Action.ask_input, _("What should the new name of {} be?").format(name), name, "rename {}".format(name)])
else:
old_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(name))
new_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(new_name))
os.rename(old_file_path, new_file_path)
if self.git_repo:
porcelain.add(self.git_repo, [old_file_path, new_file_path])
porcelain.commit(self.git_repo, message="Renamed {} to {} with Pext".format(name, new_name))
self._git_push()
self.q.put([Action.set_selection, []])
def commit_and_push(version: str) -> None:
"""
Commit and push all changes.
"""
repo = Repo('.')
paths = ['dcosdocker.rb', 'CHANGELOG.rst', 'vagrant/Vagrantfile']
_, ignored = add(paths=paths)
assert not ignored
message = b'Update for release ' + version.encode('utf-8')
commit(message=message)
branch_name = 'master'
push(
repo=repo,
remote_location='[email protected]:mesosphere/dcos-e2e.git',
refspecs=branch_name.encode('utf-8'),
)
def test_get_tree_changes_delete(self):
"""Unit test for get_tree_changes delete."""
# Make a dummy file, stage, commit, remove
filename = "foo"
with open(os.path.join(self.repo.path, filename), "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b"test status", author=b"", committer=b"")
porcelain.rm(repo=self.repo.path, paths=[filename])
changes = porcelain.get_tree_changes(self.repo.path)
self.assertEqual(changes["delete"][0], filename.encode("ascii"))
self.assertEqual(len(changes["add"]), 0)
self.assertEqual(len(changes["modify"]), 0)
self.assertEqual(len(changes["delete"]), 1)
def delete(self, request, user, data, message=None):
'''Delete file(s) from repository
'''
files_to_del = data.get('files')
if not files_to_del:
raise DataError('Nothing to delete')
# convert to list if not already
if not isinstance(files_to_del, (list, tuple)):
files_to_del = [files_to_del]
filenames = []
path = self.path
for file in files_to_del:
filepath = os.path.join(path, self._format_filename(file))
# remove only files that really exist and not dirs
if os.path.exists(filepath) and os.path.isfile(filepath):
# remove from disk
os.remove(filepath)
filename = get_rel_dir(filepath, self.repo.path)
filenames.append(filename)
if filenames:
rm(self.repo, filenames)
if not message:
message = 'Deleted %s' % ';'.join(filenames)
return commit(self.repo, _b(message),
committer=_b(user.username))
def commit_and_push(version: str, repository: Repository) -> None:
"""
Commit and push all changes.
"""
local_repository = Repo('.')
paths = ['CHANGELOG.rst']
_, ignored = add(paths=paths)
assert not ignored
message = b'Update for release ' + version.encode('utf-8')
commit(message=message)
branch_name = 'master'
push(
repo=local_repository,
remote_location=repository.ssh_url,
refspecs=branch_name.encode('utf-8'),
)
def test_remove_file(self):
fullpath = os.path.join(self.repo.path, 'foo')
with open(fullpath, 'w') as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=[fullpath])
porcelain.commit(repo=self.repo, message=b'test',
author=b'test <email>',
committer=b'test <email>')
self.assertTrue(os.path.exists(os.path.join(self.repo.path, 'foo')))
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
porcelain.remove(self.repo.path, paths=["foo"])
finally:
os.chdir(cwd)
self.assertFalse(os.path.exists(os.path.join(self.repo.path, 'foo')))
def test_simple(self):
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, 'foo')
with open(fullpath, 'w') as f:
f.write('origstuff')
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'author <email>',
committer=b'committer <email>')
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
self.assertEqual(
f.getvalue(),
'100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n')
def test_remove_file(self):
fullpath = os.path.join(self.repo.path, 'foo')
with open(fullpath, 'w') as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=[fullpath])
porcelain.commit(repo=self.repo, message=b'test',
author=b'test <email>',
committer=b'test <email>')
self.assertTrue(os.path.exists(os.path.join(self.repo.path, 'foo')))
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
porcelain.remove(self.repo.path, paths=["foo"])
finally:
os.chdir(cwd)
self.assertFalse(os.path.exists(os.path.join(self.repo.path, 'foo')))
def git_reset_repo_to_origin():
try:
repo = porcelain.Repo(database)
porcelain.fetch(repo)
tree_head_id = repo[repo[b'refs/heads/master'].tree].id
tree_origin_master_id = repo[
repo[b'refs/remotes/origin/master'].tree].id
store = repo.object_store
list_all_files_head = list_all_files(store, tree_head_id)
list_all_files_origin_master = list_all_files(store,
tree_origin_master_id)
deleted_files = list(
set(list_all_files_head) - set(list_all_files_origin_master))
# print(deleted_files)
if deleted_files != []:
for all in deleted_files:
file_path = os.path.join(database, all.decode('utf-8'))
os.remove(file_path)
status = porcelain.status(repo)
repo.stage(status.unstaged)
porcelain.commit(repo, message="delete files")
###working###
porcelain.reset(repo, "hard", treeish=b"refs/remotes/origin/master")
porcelain.clean(repo=repo, target_dir=database)
resolve_divergence()
########
return True
except MaxRetryError:
print('MaxRetryError')
return False
except ProtocolError:
print('ProtocolError')
return False
def _remove(self, name=None, confirmed=None):
if not name:
self.q.put([Action.ask_input, _("Remove which password?"), "", "remove"])
elif confirmed is None:
self.q.put([Action.ask_question, _("Are you sure you want to remove {}?").format(name), "remove {}".format(name)])
elif not confirmed:
return
else:
file_path = os.path.join(self._get_data_location(), "{}.gpg".format(name))
os.remove(file_path)
if self.git_repo:
porcelain.add(self.git_repo, [file_path])
porcelain.commit(self.git_repo, message="Removed {} with Pext".format(name))
self._git_push()
self.q.put([Action.set_selection, []])
def test_some(self):
cid = porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'', committer=b'')
self.assertEqual({
b'refs/heads/master': cid,
b'HEAD': cid},
porcelain.ls_remote(self.repo.path))
def upload(self, cmd: str, meta: dict):
index = os.path.join(self.cached_repo, INDEX_FILE)
if os.path.exists(index):
os.remove(index)
self._log.info("Writing the new index.json ...")
with open(index, "w") as _out:
json.dump(self.contents, _out)
# implementation of git add --all is pretty bad, changing directory is the easiest way
os.chdir(self.cached_repo)
git.add()
git.commit(message=self.COMMIT_MESSAGES[cmd].format(**meta))
self._log.info("Pushing the updated index ...")
# TODO: change when https://github.com/dulwich/dulwich/issues/631 gets addressed
git.push(self.cached_repo, self.remote_url, b"master")
if self._are_local_and_remote_heads_different():
self._log.error("Push has failed")
raise ValueError
def test_some(self):
cid = porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'', committer=b'')
self.assertEqual({
b'refs/heads/master': cid,
b'HEAD': cid},
porcelain.ls_remote(self.repo.path))
def test_with_remote_name(self):
remote_name = b'origin'
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test <email>',
committer=b'test <email>')
# Setup target repo
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
target_repo = porcelain.clone(self.repo.path, target=target_path,
errstream=errstream)
# Capture current refs
target_refs = target_repo.get_refs()
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(repo=self.repo.path, message=b'test2',
author=b'test2 <email>',
committer=b'test2 <email>')
self.assertFalse(self.repo[b'HEAD'].id in target_repo)
target_repo.close()
# Fetch changes into the cloned repo
porcelain.fetch(target_path, self.repo.path, remote_name=remote_name,
outstream=outstream, errstream=errstream)
# Assert that fetch updated the local image of the remote
self.assert_correct_remote_refs(
target_repo.get_refs(), self.repo.get_refs())
# Check the target repo for pushed changes, as well as updates
# for the refs
with Repo(target_path) as r:
self.assertTrue(self.repo[b'HEAD'].id in r)
self.assertNotEqual(self.repo.get_refs(), target_refs)
def test_custom_author(self):
c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
[3, 1, 2]])
self.repo.refs[b"refs/heads/foo"] = c3.id
sha = porcelain.commit(self.repo.path, message=b"Some message",
author=b"Joe <*****@*****.**>", committer=b"Bob <*****@*****.**>")
self.assertTrue(isinstance(sha, bytes))
self.assertEqual(len(sha), 40)
def test_get_tree_changes_delete(self):
"""Unit test for get_tree_changes delete."""
# Make a dummy file, stage, commit, remove
filename = 'foo'
with open(os.path.join(self.repo.path, filename), 'w') as f:
f.write('stuff')
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'', committer=b'')
porcelain.rm(repo=self.repo.path, paths=[filename])
changes = porcelain.get_tree_changes(self.repo.path)
self.assertEqual(changes['delete'][0], filename.encode('ascii'))
self.assertEqual(len(changes['add']), 0)
self.assertEqual(len(changes['modify']), 0)
self.assertEqual(len(changes['delete']), 1)
def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path,
message=b'test',
author=b'test',
committer=b'test')
# Setup target repo
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
target_repo = porcelain.clone(self.repo.path,
target=target_path,
errstream=errstream)
target_repo.close()
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
filename = os.path.basename(fullpath)
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path,
message=b'test2',
author=b'test2',
committer=b'test2')
self.assertTrue(b'refs/heads/master' in self.repo.refs)
self.assertTrue(b'refs/heads/master' in target_repo.refs)
# Pull changes into the cloned repo
porcelain.pull(target_path,
self.repo.path,
b'refs/heads/master',
outstream=outstream,
errstream=errstream)
# Check the target repo for pushed changes
with closing(Repo(target_path)) as r:
self.assertEqual(r[b'HEAD'].id, self.repo[b'HEAD'].id)
def push(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
username = self.username.text()
userid = self.userid.text()
password = self.password.text()
reponame = self.reponame.text()
settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
QCoreApplication.organizationName(),
QCoreApplication.applicationName())
settings.setValue("github.userid", userid)
settings.setValue("github.username", username)
settings.setValue("github.reponame", reponame)
os.chdir(self.site_path)
gitpath = os.path.join(self.site_path, ".git")
if os.path.exists(gitpath):
repo = porcelain.open_repo(self.site_path)
else:
repo = porcelain.init(self.site_path)
for r, dirs, files in os.walk(self.site_path):
for f in files:
p = os.path.join(r, f)[len(self.site_path) + 1:]
if not ".git" in p:
porcelain.add(repo, p)
self.html = "<p>adding: " + p + "</p>" + self.html
self.browser.setHtml(self.html)
QCoreApplication.processEvents()
self.html = "<p>Commiting changes</p>" + self.html
self.browser.setHtml(self.html)
QCoreApplication.processEvents()
porcelain.commit(repo, b"A sample commit")
self.html = "<p>Pushing to server</p>" + self.html
self.browser.setHtml(self.html)
QCoreApplication.processEvents()
porcelain.push(
self.site_path, "https://" + userid + ":" + password +
"@github.com/" + username + "/" + reponame + ".git", "master")
self.html = "<p>Ready</p>" + self.html
self.browser.setHtml(self.html)
QCoreApplication.processEvents()
QApplication.restoreOverrideCursor()
def test_add_default_paths_subdir(self):
os.mkdir(os.path.join(self.repo.path, 'foo'))
with open(os.path.join(self.repo.path, 'blah'), 'w') as f:
f.write("\n")
with open(os.path.join(self.repo.path, 'foo', 'blie'), 'w') as f:
f.write("\n")
cwd = os.getcwd()
try:
os.chdir(os.path.join(self.repo.path, 'foo'))
porcelain.add(repo=self.repo.path)
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test', committer=b'test')
finally:
os.chdir(cwd)
index = self.repo.open_index()
self.assertEqual(sorted(index), [b'foo/blie'])
def test_simple(self):
"""
Basic test of porcelain push where self.repo is the remote. First
clone the remote, commit a file to the clone, then push the changes
back to the remote.
"""
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(repo=self.repo.path, message=b'init',
author=b'', committer=b'')
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.clone(self.repo.path, target=clone_path,
errstream=errstream)
target_repo.close()
# create a second file to be pushed back to origin
handle, fullpath = tempfile.mkstemp(dir=clone_path)
os.close(handle)
porcelain.add(repo=clone_path, paths=[os.path.basename(fullpath)])
porcelain.commit(repo=clone_path, message=b'push',
author=b'', committer=b'')
# Setup a non-checked out branch in the remote
refs_path = b"refs/heads/foo"
self.repo.refs[refs_path] = self.repo[b'HEAD'].id
# Push to the remote
porcelain.push(clone_path, self.repo.path, b"HEAD:" + refs_path, outstream=outstream,
errstream=errstream)
# Check that the target and source
with closing(Repo(clone_path)) as r_clone:
self.assertEqual(r_clone[b'HEAD'].id, self.repo[refs_path].id)
# Get the change in the target repo corresponding to the add
# this will be in the foo branch.
change = list(tree_changes(self.repo, self.repo[b'HEAD'].tree,
self.repo[b'refs/heads/foo'].tree))[0]
self.assertEqual(os.path.basename(fullpath),
change.new.path.decode('ascii'))
def save(self):
primer_dir = pathlib.Path(self.confdir)
primer_project_dir = primer_dir / 'projects'
project_dir = pathlib.Path(self.name)
project = self.name
if self.base:
project_dir = self.base / project_dir
if project_dir.exists():
raise exceptions.ProjectFolderExistsError(self.name)
if not primer_project_dir.exists():
primer_project_dir.mkdir(parents=True, exist_ok=True)
repo = porcelain.init(str(primer_dir))
else:
repo = Repo(str(primer_dir))
projects_yml = primer_dir / 'projects.yml'
if projects_yml.exists():
with projects_yml.open('r') as yml_file:
projects_def = yaml.load(yml_file, Loader=Loader)
projects = projects_def['primer']['projects']
if project in projects:
raise exceptions.ProjectExistsError(self.name)
projects.append(project)
else:
projects_def = OrderedDict()
projects_def['version'] = 1
projects_def['primer'] = {'projects': [self.name]}
with projects_yml.open('w') as yml_file:
yaml.dump(projects_def,
yml_file,
default_flow_style=False,
Dumper=Dumper)
project_dir.mkdir(parents=True, exist_ok=True)
header = OrderedDict()
header['version'] = 1
header['primer'] = {'repositories': {}, 'directory': str(project_dir)}
primer_yml = primer_project_dir / '{}.yml'.format(self.name)
with primer_yml.open('w') as yml_file:
yaml.dump(header,
yml_file,
default_flow_style=False,
Dumper=Dumper)
porcelain.add(repo, primer_yml)
porcelain.commit(repo, message="added {}".format(self.name))
def test_add_default_paths_subdir(self):
os.mkdir(os.path.join(self.repo.path, 'foo'))
with open(os.path.join(self.repo.path, 'blah'), 'w') as f:
f.write("\n")
with open(os.path.join(self.repo.path, 'foo', 'blie'), 'w') as f:
f.write("\n")
cwd = os.getcwd()
try:
os.chdir(os.path.join(self.repo.path, 'foo'))
porcelain.add(repo=self.repo.path)
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test <email>',
committer=b'test <email>')
finally:
os.chdir(cwd)
index = self.repo.open_index()
self.assertEqual(sorted(index), [b'foo/blie'])
def test_add_default_paths(self):
# create a file for initial commit
with open(os.path.join(self.repo.path, "blah"), "w") as f:
f.write("\n")
porcelain.add(repo=self.repo.path, paths=["blah"])
porcelain.commit(repo=self.repo.path, message=b"test", author=b"test", committer=b"test")
# Add a second test file and a file in a directory
with open(os.path.join(self.repo.path, "foo"), "w") as f:
f.write("\n")
os.mkdir(os.path.join(self.repo.path, "adir"))
with open(os.path.join(self.repo.path, "adir", "afile"), "w") as f:
f.write("\n")
porcelain.add(self.repo.path)
# Check that foo was added and nothing in .git was modified
index = self.repo.open_index()
self.assertEqual(sorted(index), [b"adir/afile", b"blah", b"foo"])
def save(self, model, path=''):
self.notebook_dir = super(GitNotebookManager, self)._get_os_path("")
self._check_repo()
model = super(GitNotebookManager, self).save(model, path)
os_path = super(GitNotebookManager, self)._get_os_path(model['path'])
local_path = os_path[len(self.notebook_dir):].strip('/')
git.add(self._repo, [str(local_path)]) # path must not be unicode. :(
if self.save_script:
git.add(self._repo, [str(os.path.splitext(local_path)[0] + '.py')])
self.log.debug("Notebook added %s" % local_path)
git.commit(self._repo, "IPython notebook save\n\n"
"Automated commit from IPython via ipylogue",
committer=self.committer_fullname)
return model
def dbBlock(args, api=False, toggle=True):
# Retrieve user record
db = TinyDB(args.userdb, **db_format)
User = Query()
if api:
table = db.table('api_users')
else:
table = db
if toggle:
verb = ('Block', 'Blocking', 'blocked')
else:
verb = ('Unblock', 'Unblocking', 'unblocked')
user_list = table.search(User.userid == args.userid)
status = len(user_list)
if status < 1:
print('User {} not found. Exiting.'.format(args.userid))
sys.exit(1)
elif status > 1:
print('ID not unique. Is there a problem in the database?')
sys.exit(2)
print('{} user {}...'.format(verb[1], args.userid))
user = user_list[0]
# Update user record
table.update({'blocked': toggle}, doc_ids=[user.doc_id])
# Add file to Git index
try:
repo = Repo(os.path.dirname(args.userdb))
except NotGitRepository:
repo = Repo.init(os.path.dirname(args.userdb))
git.add(repo=repo, paths=[args.userdb])
# Prepare commit information
committer = 'MSCWG <{}>'.format(mscwg_email).encode('utf8')
author = committer
message = ('{} user {}\n\nChanged by dbctl.py'.format(
verb[0], args.userid).encode('utf8'))
# Execute commit
git.commit(repo, message=message, author=author, committer=committer)
print('\nUser successfully {}'.format(verb[2]))
def test_hard_head(self):
with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=["foo"])
porcelain.commit(self.repo.path, message=b"Some message",
committer=b"Jane <*****@*****.**>",
author=b"John <*****@*****.**>")
with open(os.path.join(self.repo.path, 'foo'), 'wb') as f:
f.write(b"OOH")
porcelain.reset(self.repo, "hard", b"HEAD")
index = self.repo.open_index()
changes = list(tree_changes(self.repo,
index.commit(self.repo.object_store),
self.repo[b'HEAD'].tree))
self.assertEqual([], changes)
def _append_password(self, name, value):
current_data = self.password_store.get_decrypted_password(name)
if not current_data.endswith('\n'):
current_data = "{}\n".format(current_data)
if not value.endswith('\n'):
value = "{}\n".format(value)
self.password_store.insert_password(name,
"{}{}".format(current_data, value))
if self.git_repo:
porcelain.add(
self.git_repo,
os.path.join(self._get_data_location(), "{}.gpg".format(name)))
porcelain.commit(self.git_repo,
message="Appended to {} with Pext".format(name))
self._git_push()
def test_simple(self):
"""
Basic test of porcelain push where self.repo is the remote. First
clone the remote, commit a file to the clone, then push the changes
back to the remote.
"""
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(repo=self.repo.path, message=b'init',
author=b'', committer=b'')
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
target_repo = porcelain.clone(self.repo.path, target=clone_path, errstream=errstream)
target_repo.close()
# create a second file to be pushed back to origin
handle, fullpath = tempfile.mkstemp(dir=clone_path)
os.close(handle)
porcelain.add(repo=clone_path, paths=[os.path.basename(fullpath)])
porcelain.commit(repo=clone_path, message=b'push',
author=b'', committer=b'')
# Setup a non-checked out branch in the remote
refs_path = b"refs/heads/foo"
self.repo[refs_path] = self.repo[b'HEAD']
# Push to the remote
porcelain.push(clone_path, self.repo.path, refs_path, outstream=outstream,
errstream=errstream)
# Check that the target and source
with closing(Repo(clone_path)) as r_clone:
# Get the change in the target repo corresponding to the add
# this will be in the foo branch.
change = list(tree_changes(self.repo, self.repo[b'HEAD'].tree,
self.repo[b'refs/heads/foo'].tree))[0]
self.assertEqual(r_clone[b'HEAD'].id, self.repo[refs_path].id)
self.assertEqual(os.path.basename(fullpath), change.new.path.decode('ascii'))
def _copy(self, name=None, copy_name=None):
if not name:
self.q.put([Action.ask_input, _("Copy which password?"), "", "copy"])
elif not copy_name:
self.q.put([Action.ask_input, _("What should the copy of {} be named?").format(name), name, "copy {}".format(name)])
else:
try:
original_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(name))
copy_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(copy_name))
shutil.copyfile(original_file_path, copy_file_path)
if self.git_repo:
porcelain.add(self.git_repo, [copy_file_path])
porcelain.commit(self.git_repo, message="Copied {} to {} with Pext".format(name, copy_name))
self._git_push()
except shutil.SameFileError:
self.q.put([Action.ask_input, _("What should the copy of {} be named?").format(name), name, "copy {}".format(name)])
return
self.q.put([Action.set_selection, []])
def test_add_default_paths(self):
# create a file for initial commit
with open(os.path.join(self.repo.path, 'blah'), 'w') as f:
f.write("\n")
porcelain.add(repo=self.repo.path, paths=['blah'])
porcelain.commit(repo=self.repo.path, message=b'test',
author=b'test', committer=b'test')
# Add a second test file and a file in a directory
with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
f.write("\n")
os.mkdir(os.path.join(self.repo.path, 'adir'))
with open(os.path.join(self.repo.path, 'adir', 'afile'), 'w') as f:
f.write("\n")
porcelain.add(self.repo.path)
# Check that foo was added and nothing in .git was modified
index = self.repo.open_index()
self.assertEqual(sorted(index), [b'adir/afile', b'blah', b'foo'])
def test_get_tree_changes_modify(self):
"""Unit test for get_tree_changes modify."""
# Make a dummy file, stage, commit, modify
filename = 'foo'
fullpath = os.path.join(self.repo.path, filename)
with open(fullpath, 'w') as f:
f.write('stuff')
porcelain.add(repo=self.repo.path, paths=filename)
porcelain.commit(repo=self.repo.path, message='test status',
author='', committer='')
with open(fullpath, 'w') as f:
f.write('otherstuff')
porcelain.add(repo=self.repo.path, paths=filename)
changes = porcelain.get_tree_changes(self.repo.path)
self.assertEqual(changes['modify'][0], filename)
self.assertEqual(len(changes['add']), 0)
self.assertEqual(len(changes['modify']), 1)
self.assertEqual(len(changes['delete']), 0)
def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(repo=self.repo.path,
message=b'test',
author=b'test <email>',
committer=b'test <email>')
# Setup target repo
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
target_repo = porcelain.clone(self.repo.path,
target=target_path,
errstream=errstream)
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(repo=self.repo.path,
message=b'test2',
author=b'test2 <email>',
committer=b'test2 <email>')
self.assertFalse(self.repo[b'HEAD'].id in target_repo)
target_repo.close()
# Fetch changes into the cloned repo
porcelain.fetch(target_path,
self.repo.path,
outstream=outstream,
errstream=errstream)
# Check the target repo for pushed changes
with Repo(target_path) as r:
self.assertTrue(self.repo[b'HEAD'].id in r)
def update(repo_url, logger=None):
if logger:
logger.info("Updating docs for: %s", repo_url)
else:
print("Updating docs for: %s" % repo_url)
try:
shutil.rmtree(package_folder_name)
except:
pass
repo = porcelain.clone(package_git_url, package_folder_name)
refspecs = b"HEAD:refs/heads/%s" %package_git_branch
porcelain.pull(repo, package_git_url, refspecs = refspecs)
repo_url = repo_url.split("\n")[0]
repo_name = repo_url.split('/')[-1]
readme_md, readme_name = loadReadme(repo_url)
readme_md, readme_title = addTitleToReadme(readme_md, repo_url)
readme_md = addEditLink(readme_md, readme_name, repo_url)
updateMenu(readme_md, repo_name, repo)
updateReadmePage(readme_md, repo_name, repo)
updateLandingPage(readme_title, repo)
staged = porcelain.status(repo).staged
if (len(staged['add']) == 0) and (len(staged['modify']) == 0):
if logger:
logger.info("No changes to commit")
else:
print("No changes to commit")
else:
if logger:
logger.info("Commiting changes for %s", repo_name)
else:
print("Commiting changes for %s" % repo_name)
porcelain.commit(repo, b"Updated docs for %s" % repo_name)
porcelain.push(repo, package_git_url, refspecs = refspecs)
try:
shutil.rmtree(package_folder_name)
except Exception, err:
if logger:
logger.exception(err)
else:
print(err)
def test_get_tree_changes_modify(self):
"""Unit test for get_tree_changes modify."""
# Make a dummy file, stage, commit, modify
filename = 'foo'
fullpath = os.path.join(self.repo.path, filename)
with open(fullpath, 'w') as f:
f.write('stuff')
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(repo=self.repo.path, message=b'test status',
author=b'author <email>',
committer=b'committer <email>')
with open(fullpath, 'w') as f:
f.write('otherstuff')
porcelain.add(repo=self.repo.path, paths=fullpath)
changes = porcelain.get_tree_changes(self.repo.path)
self.assertEqual(changes['modify'][0], filename.encode('ascii'))
self.assertEqual(len(changes['add']), 0)
self.assertEqual(len(changes['modify']), 1)
self.assertEqual(len(changes['delete']), 0)
def rename_file(self, old_path, new_path):
# paths must not be unicode. :(
old_files = [old_path]
new_files = [new_path]
if self.save_script:
old_files.append(old_files[0].replace('.ipynb', '.py'))
new_files.append(new_files[0].replace('.ipynb', '.py'))
git.rm(self._repo, [str(_) for _ in old_files])
renamed = super(GitNotebookManager,
self).rename_file(old_path, new_path)
git.add(self._repo, [str(_) for _ in new_files])
self.log.debug("Notebook renamed from '%s' to '%s'" %
(old_files[0], new_files[0]))
git.commit(self._repo, "IPython notebook rename\n\n"
"Automated commit from IPython via ipylogue",
committer=self.committer_fullname)
return renamed
def git_push_to_origin(ui, admin, file_list, message, worker_text):
# local_appdata = os.getenv('LOCALAPPDATA')
# credentials_file = os.path.join(os.getenv('LOCALAPPDATA'),"LaMA", "credentials","developer_credentials.txt")
if admin == True:
access_token = get_access_token('developer')
else:
access_token = get_access_token('user')
repo = porcelain.open_repo(database)
if admin == True:
status = porcelain.status(repo)
repo.stage(status.unstaged + status.untracked)
# print(status.unstaged)
# print(status.untracked)
if status.unstaged == [] and status.untracked == []:
# information_window("Es wurden keine Änderungen gefunden.")
return False
for file in file_list:
file_path = os.path.join(database, file)
porcelain.add(repo, paths=file_path)
ui.label.setText("{} (27%)".format(worker_text))
if admin == True:
mode = 'Administrator'
else:
mode = 'User'
porcelain.commit(repo,
message="New Update ({0}) - {1}".format(mode, message))
ui.label.setText("{} (84%)".format(worker_text))
porcelain.push(
repo,
"https://*****:*****@github.com/chrisiweb/lama_latest_update.git".
format(access_token), "master")
ui.label.setText("{} (100%)".format(worker_text))
return True
