Esperienze del modulo Python Git? [chiuso]

Quali sono le esperienze delle persone con uno qualsiasi dei moduli Git per Python? (Conosco GitPython, PyGit e Dulwich - sentiti libero di menzionare gli altri se ne conosci.)

Sto scrivendo un programma che dovrà interagire (aggiungere, eliminare, eseguire il commit) con un repository Git, ma non ho esperienza con Git, quindi una delle cose che sto cercando è la facilità d'uso / comprensione nei confronti di Git.

Le altre cose che mi interessano principalmente sono la maturità e la completezza della biblioteca, una ragionevole mancanza di bug, lo sviluppo continuo e la disponibilità della documentazione e degli sviluppatori.

Se pensi a qualcos'altro che potrei desiderare / aver bisogno di sapere, non esitare a menzionarlo.

Mentre questa domanda è stata posta qualche tempo fa e non conosco lo stato delle librerie a quel punto, vale la pena menzionare per i ricercatori che GitPython fa un buon lavoro di astrazione degli strumenti della riga di comando in modo che non sia necessario utilizzare sottoprocesso. Ci sono alcune utili astrazioni integrate che puoi usare, ma per tutto il resto puoi fare cose come:

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()

Tutto il resto in GitPython semplifica la navigazione. Sono abbastanza soddisfatto di questa libreria e apprezzo che sia un wrapper sugli strumenti git sottostanti.

AGGIORNAMENTO : Sono passato all'utilizzo del modulo sh non solo per git ma la maggior parte delle utility da riga di comando di cui ho bisogno in Python. Per replicare quanto sopra farei invece questo:

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()

Ho pensato di rispondere alla mia domanda, dato che sto prendendo una strada diversa da quella suggerita nelle risposte. Tuttavia, grazie a coloro che hanno risposto.

Innanzitutto, una breve sinossi delle mie esperienze con GitPython, PyGit e Dulwich:

• GitPython : Dopo il download, ho importato questo e inizializzato l'oggetto appropriato. Tuttavia, provare a fare ciò che è stato suggerito nel tutorial ha portato a errori. In mancanza di ulteriore documentazione, mi sono rivolto altrove.
• PyGit : Questo non sarebbe nemmeno importato e non ho trovato documentazione.
• Dulwich : sembra essere il più promettente (almeno per quello che volevo e vedevo). Ho fatto qualche progresso con esso, più che con GitPython, dal momento che il suo uovo viene fornito con sorgente Python. Tuttavia, dopo un po ', ho deciso che potrebbe essere più semplice provare quello che ho fatto.

Inoltre, StGit sembra interessante, ma avrei bisogno della funzionalità estratta in un modulo separato e non voglio aspettare che ciò accada in questo momento.

In (molto) meno tempo di quanto ho passato a cercare di far funzionare i tre moduli sopra, sono riuscito a far funzionare i comandi git tramite il modulo di sottoprocesso, ad es.

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')

Questo non è ancora completamente incorporato nel mio programma, ma non sto anticipando un problema, tranne forse la velocità (poiché a volte elaborerò centinaia o addirittura migliaia di file).

Forse non ho avuto la pazienza di far andare le cose con Dulwich o GitPython. Detto questo, spero che i moduli avranno più sviluppo e saranno presto più utili.

Consiglierei pygit2 - usa gli eccellenti collegamenti libgit2

Questa è una domanda piuttosto vecchia e, mentre cercavo le librerie Git, ne ho trovata una creata quest'anno (2013) chiamata Gittle .

Ha funzionato alla grande per me (dove gli altri che ho provato erano traballanti) e sembra coprire la maggior parte delle azioni comuni.

Alcuni esempi dal 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()

Forse aiuta, ma Bazaar e Mercurial usano entrambi Dulwich per la loro interoperabilità Git.

Dulwich è probabilmente diverso dall'altro nel senso che è una reimplementazione di git in Python. L'altro potrebbe essere solo un involucro attorno ai comandi di Git (quindi potrebbe essere più semplice da usare da un punto di vista di alto livello: commit / add / delete), probabilmente significa che la loro API è molto vicina alla riga di comando di git quindi avrai bisogno per acquisire esperienza con Git.

Per completezza, http://github.com/alex/pyvcs/ è un livello di astrazione per tutti i dvcs. Usa dulwich, ma fornisce l'interoperabilità con gli altri dvcs.

Una risposta aggiornata che riflette i tempi modificati:

GitPython è attualmente il più semplice da usare. Supporta il wrapping di molti comandi idraulici git e ha un database di oggetti innestabile (dulwich è uno di questi) e, se un comando non è implementato, fornisce un'API semplice per sgusciare fuori dalla riga di comando. Per esempio:

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

Questo chiama:

bash$ git checkout -b new_branch

Anche Dulwich è buono ma di livello molto più basso. È un po 'una seccatura da usare perché richiede di operare su oggetti git a livello dell'impianto idraulico e non ha una bella porcellana che normalmente vorresti fare. Tuttavia, se hai intenzione di modificare parti di git o usi git-rece-pack e git-upload-pack, devi usare dulwich.

Ecco un'implementazione molto rapida di "stato 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() )

La risposta di PTBNL è abbastanza perfetta per me. Faccio un po 'di più per l'utente di 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)

La parte della libreria di interazione git di StGit è in realtà piuttosto buona. Tuttavia, non è suddiviso in un pacchetto separato, ma se l'interesse è sufficiente, sono sicuro che può essere risolto.

Ha delle astrazioni molto belle per rappresentare commit, alberi ecc. E per creare nuovi commit e alberi.

Per la cronaca, nessuna delle librerie Git Python sopra menzionate sembra contenere un equivalente dello "stato git", che è davvero l'unica cosa che vorrei, dal momento che gestire il resto dei comandi git tramite sottoprocesso è così semplice.