Doświadczenia z modułem Python Git? [Zamknięte]

Jakie są doświadczenia ludzi z którymkolwiek z modułów Git dla Pythona? (Znam GitPython, PyGit i Dulwich - nie wahaj się wspomnieć o innych, jeśli je znasz.)

Piszę program, który będzie musiał wchodzić w interakcje (dodawać, usuwać, zatwierdzać) z repozytorium Git, ale nie mam doświadczenia z Git, więc jedną z rzeczy, których szukam, jest łatwość użytkowania / zrozumienia w odniesieniu do Git.

Innymi rzeczami, które interesują mnie przede wszystkim, są dojrzałość i kompletność biblioteki, rozsądny brak błędów, ciągły rozwój oraz przydatność dokumentacji i programistów.

Jeśli myślisz o czymś innym, co chciałbym / chciałbym wiedzieć, nie wahaj się o tym wspomnieć.

Chociaż to pytanie zostało zadane jakiś czas temu i nie znam stanu bibliotek w tamtym momencie, warto wspomnieć osobom wyszukującym, że GitPython dobrze radzi sobie z abstrakcją narzędzi wiersza poleceń, aby nie trzeba było używać podproces. Istnieje kilka użytecznych abstrakcji, których możesz użyć, ale w przypadku wszystkiego innego możesz wykonać takie czynności, jak:

import git
repo = git.Repo( '/home/me/repodir' )
print repo.git.status()
# checkout and track a remote branch
print repo.git.checkout( 'origin/somebranch', b='somebranch' )
# add a file
print repo.git.add( 'somefile' )
# commit
print repo.git.commit( m='my commit message' )
# now we are one commit ahead
print repo.git.status()

Wszystko inne w GitPythonie po prostu ułatwia nawigację. Jestem dość zadowolony z tej biblioteki i doceniam, że jest ona opakowaniem podstawowych narzędzi git.

AKTUALIZACJA : Przerzuciłem się na używanie modułu sh dla nie tylko git, ale większości narzędzi wiersza poleceń, których potrzebuję w Pythonie. Aby powtórzyć powyższe, zrobiłbym to zamiast tego:

import sh
git = sh.git.bake(_cwd='/home/me/repodir')
print git.status()
# checkout and track a remote branch
print git.checkout('-b', 'somebranch')
# add a file
print git.add('somefile')
# commit
print git.commit(m='my commit message')
# now we are one commit ahead
print git.status()

Pomyślałem, że odpowiem na własne pytanie, ponieważ podążam inną drogą niż sugerowano w odpowiedziach. Niemniej jednak dziękuję tym, którzy odpowiedzieli.

Najpierw krótkie streszczenie moich doświadczeń z GitPythonem, PyGit i Dulwich:

• GitPython : Po pobraniu zaimportowałem to i zainicjowałem odpowiedni obiekt. Jednak próba zrobienia tego, co sugerowano w samouczku, doprowadziła do błędów. Z braku większej dokumentacji poszedłem gdzie indziej.
• PyGit : To by się nawet nie zaimportowało i nie mogłem znaleźć żadnej dokumentacji.
• Dulwich : Wydaje się, że jest najbardziej obiecujący (przynajmniej ze względu na to, co chciałem i widziałem). Zrobiłem w nim pewien postęp, większy niż w przypadku GitPythona, ponieważ jego jajko jest dostarczane ze źródłem Pythona. Jednak po pewnym czasie zdecydowałem, że może być łatwiej spróbować tego, co zrobiłem.

Również StGit wygląda interesująco, ale potrzebowałbym funkcji wyodrębnionej w osobnym module i nie chcę czekać, aż to się stanie teraz.

W (dużo) mniej czasu niż spędziłem na próbach uruchomienia trzech powyższych modułów, udało mi się uzyskać polecenia git działające za pośrednictwem modułu podprocesu, np.

def gitAdd(fileName, repoDir):
    cmd = ['git', 'add', fileName]
    p = subprocess.Popen(cmd, cwd=repoDir)
    p.wait()

gitAdd('exampleFile.txt', '/usr/local/example_git_repo_dir')

Nie jest to jeszcze w pełni włączone do mojego programu, ale nie przewiduję problemu, może z wyjątkiem szybkości (ponieważ będę przetwarzać setki lub nawet tysiące plików czasami).

Może po prostu nie miałem cierpliwości, aby wszystko działało z Dulwich lub GitPythonem. To powiedziawszy, mam nadzieję, że moduły będą bardziej rozbudowywane i wkrótce będą bardziej przydatne.

Polecam pygit2 - wykorzystuje doskonałe libgit2 powiązania

To dość stare pytanie i szukając bibliotek Git, znalazłem taką, która została stworzona w tym roku (2013) o nazwie Gittle .

Działało świetnie dla mnie (gdzie inne, których próbowałem, były niestabilne) i wydaje się, że obejmuje większość typowych działań.

Kilka przykładów z README:

from gittle import Gittle

# Clone a repository
repo_path = '/tmp/gittle_bare'
repo_url = 'git://github.com/FriendCode/gittle.git'
repo = Gittle.clone(repo_url, repo_path)

# Stage multiple files
repo.stage(['other1.txt', 'other2.txt'])

# Do the commit
repo.commit(name="Samy Pesse", email="samy@friendco.de", message="This is a commit")

# Authentication with RSA private key
key_file = open('/Users/Me/keys/rsa/private_rsa')
repo.auth(pkey=key_file)

# Do push
repo.push()

Może to pomaga, ale Bazaar i Mercurial używają Dulwich ze względu na interoperacyjność Git.

Dulwich prawdopodobnie różni się od innych w tym sensie, że jest to reimplementacja gita w Pythonie. Drugi może być po prostu otoką wokół poleceń Gita (więc może być prostszy w użyciu z wysokiego poziomu: zatwierdzanie / dodawanie / usuwanie), prawdopodobnie oznacza to, że ich API jest bardzo zbliżone do wiersza poleceń gita, więc będziesz potrzebować zdobyć doświadczenie z Git.

Ze względu na kompletność, http://github.com/alex/pyvcs/ jest warstwą abstrakcji dla wszystkich dvcs. Używa dulwich, ale zapewnia współdziałanie z innymi dvcs.

Zaktualizowana odpowiedź odzwierciedlająca zmienione czasy:

Obecnie GitPython jest najłatwiejszy w użyciu. Obsługuje zawijanie wielu poleceń git hydraulicznych i ma podłączalną bazę danych obiektów (jedną z nich jest dulwich), a jeśli polecenie nie jest zaimplementowane, zapewnia łatwy interfejs API do wyrzucania do wiersza poleceń. Na przykład:

repo = Repo('.')
repo.checkout(b='new_branch')

To wywołuje:

bash$ git checkout -b new_branch

Dulwich jest również dobry, ale znacznie niższy poziom. Jest to trochę uciążliwe w użyciu, ponieważ wymaga operowania na przedmiotach git na poziomie hydraulicznym i nie ma ładnej porcelany, którą normalnie chciałbyś zrobić. Jeśli jednak planujesz modyfikować jakąkolwiek część git lub używasz git-otrzymasz-pack i git-upload-pack, musisz użyć dulwich.

Oto naprawdę szybka implementacja „statusu git”:

import os
import string
from subprocess import *

repoDir = '/Users/foo/project'

def command(x):
    return str(Popen(x.split(' '), stdout=PIPE).communicate()[0])

def rm_empty(L): return [l for l in L if (l and l!="")]

def getUntracked():
    os.chdir(repoDir)
    status = command("git status")
    if "# Untracked files:" in status:
        untf = status.split("# Untracked files:")[1][1:].split("\n")
        return rm_empty([x[2:] for x in untf if string.strip(x) != "#" and x.startswith("#\t")])
    else:
        return []

def getNew():
    os.chdir(repoDir)
    status = command("git status").split("\n")
    return [x[14:] for x in status if x.startswith("#\tnew file:   ")]

def getModified():
    os.chdir(repoDir)
    status = command("git status").split("\n")
    return [x[14:] for x in status if x.startswith("#\tmodified:   ")]

print("Untracked:")
print( getUntracked() )
print("New:")
print( getNew() )
print("Modified:")
print( getModified() )

Odpowiedź PTBNL jest dla mnie idealna. Robię trochę więcej dla użytkownika Windows.

import time
import subprocess
def gitAdd(fileName, repoDir):
    cmd = 'git add ' + fileName
    pipe = subprocess.Popen(cmd, shell=True, cwd=repoDir,stdout = subprocess.PIPE,stderr = subprocess.PIPE )
    (out, error) = pipe.communicate()
    print out,error
    pipe.wait()
    return 

def gitCommit(commitMessage, repoDir):
    cmd = 'git commit -am "%s"'%commitMessage
    pipe = subprocess.Popen(cmd, shell=True, cwd=repoDir,stdout = subprocess.PIPE,stderr = subprocess.PIPE )
    (out, error) = pipe.communicate()
    print out,error
    pipe.wait()
    return 
def gitPush(repoDir):
    cmd = 'git push '
    pipe = subprocess.Popen(cmd, shell=True, cwd=repoDir,stdout = subprocess.PIPE,stderr = subprocess.PIPE )
    (out, error) = pipe.communicate()
    pipe.wait()
    return 

temp=time.localtime(time.time())
uploaddate= str(temp[0])+'_'+str(temp[1])+'_'+str(temp[2])+'_'+str(temp[3])+'_'+str(temp[4])

repoDir='d:\\c_Billy\\vfat\\Programming\\Projector\\billyccm' # your git repository , windows your need to use double backslash for right directory.
gitAdd('.',repoDir )
gitCommit(uploaddate, repoDir)
gitPush(repoDir)

Część biblioteki interakcji git w StGit jest w rzeczywistości całkiem dobra. Nie jest to jednak oddzielny pakiet, ale jeśli jest wystarczające zainteresowanie, jestem pewien, że można to naprawić.

Ma bardzo ładne abstrakcje do reprezentowania zatwierdzeń, drzew itp. Oraz do tworzenia nowych zatwierdzeń i drzew.

Dla przypomnienia, żadna z wyżej wymienionych bibliotek Git Python nie wydaje się zawierać odpowiednika "git status", co jest jedyną rzeczą, jakiej bym chciał, ponieważ radzenie sobie z resztą poleceń git za pośrednictwem podprocesu jest tak łatwe.